Import SQLite 3.8.7.4.

third_party/sqlite/src/test/malloc5.test

 # 2005 November 30
 #
 # The author disclaims copyright to this source code.  In place of
 # a legal notice, here is a blessing:
 #
 #    May you do good and not evil.
 #    May you find forgiveness for yourself and forgive others.
 #    May you share freely, never taking more than you give.
 #
 #***********************************************************************
@@ skipping 187 matching lines @@
 #
 set ::soft_limit [sqlite3_soft_heap_limit -1]
 execsql {PRAGMA cache_size=2000}
 do_test malloc5-4.1 {
   execsql {BEGIN;}
   execsql {DELETE FROM abc;}
   for {set i 0} {$i < 10000} {incr i} {
     execsql "INSERT INTO abc VALUES($i, $i, '[string repeat X 100]');"
   }
   execsql {COMMIT;}
+  db cache flush
   sqlite3_release_memory
   sqlite3_memory_highwater 1
   execsql {SELECT * FROM abc}
   set nMaxBytes [sqlite3_memory_highwater 1]
   puts -nonewline " (Highwater mark: $nMaxBytes) "
   expr $nMaxBytes > 1000000
 } {1}
 do_test malloc5-4.2 {
+  db cache flush
   sqlite3_release_memory
   sqlite3_soft_heap_limit 100000
   sqlite3_memory_highwater 1
   execsql {SELECT * FROM abc}
   set nMaxBytes [sqlite3_memory_highwater 1]
   puts -nonewline " (Highwater mark: $nMaxBytes) "
-  expr $nMaxBytes <= 100000
+  expr $nMaxBytes <= 110000
 } {1}
 do_test malloc5-4.3 {
   # Check that the content of table abc is at least roughly as expected.
   execsql {
     SELECT count(*), sum(a), sum(b) FROM abc;
   }
 } [list 10000 [expr int(10000.0 * 4999.5)] [expr int(10000.0 * 4999.5)]]
 
 # Restore the soft heap limit.
 sqlite3_soft_heap_limit $::soft_limit
@@ skipping 35 matching lines @@
 # The following test cases (malloc5-6.*) test the new global LRU list
 # used to determine the pages to recycle when sqlite3_release_memory is
 # called and there is more than one pager open.
 #
 proc nPage {db} {
   set bt [btree_from_db $db]
   array set stats [btree_pager_stats $bt]
   set stats(page)
 }
 db close
-file delete -force test.db test.db-journal test2.db test2.db-journal
+forcedelete test.db test.db-journal test2.db test2.db-journal
 
 # This block of test-cases (malloc5-6.1.*) prepares two database files
 # for the subsequent tests.
 do_test malloc5-6.1.1 {
   sqlite3 db test.db
   execsql {
     PRAGMA page_size=1024;
     PRAGMA default_cache_size=10;
   }
   execsql {
     PRAGMA temp_store = memory;
     BEGIN;
     CREATE TABLE abc(a PRIMARY KEY, b, c);
     INSERT INTO abc VALUES(randstr(50,50), randstr(75,75), randstr(100,100));
     INSERT INTO abc 
         SELECT randstr(50,50), randstr(75,75), randstr(100,100) FROM abc;
     INSERT INTO abc 
         SELECT randstr(50,50), randstr(75,75), randstr(100,100) FROM abc;
     INSERT INTO abc 
         SELECT randstr(50,50), randstr(75,75), randstr(100,100) FROM abc;
     INSERT INTO abc 
         SELECT randstr(50,50), randstr(75,75), randstr(100,100) FROM abc;
     INSERT INTO abc 
         SELECT randstr(50,50), randstr(75,75), randstr(100,100) FROM abc;
     INSERT INTO abc 
         SELECT randstr(50,50), randstr(75,75), randstr(100,100) FROM abc;
     COMMIT;
   } 
-  copy_file test.db test2.db
+  forcecopy test.db test2.db
   sqlite3 db2 test2.db
   list \
     [expr ([file size test.db]/1024)>20] [expr ([file size test2.db]/1024)>20]
 } {1 1}
 do_test malloc5-6.1.2 {
   list [execsql {PRAGMA cache_size}] [execsql {PRAGMA cache_size} db2]
 } {10 10}
 
 do_test malloc5-6.2.1 {
   execsql {SELECT * FROM abc} db2
@@ skipping 27 matching lines @@
     BEGIN;
     UPDATE abc SET c = randstr(100,100) 
     WHERE rowid = 1 OR rowid = (SELECT max(rowid) FROM abc);
   } db2
   execsql { SELECT * FROM abc } db
   expr [nPage db] + [nPage db2]
 } {20}
 do_test malloc5-6.3.2 {
   # Try to release 7700 bytes. This should release all the 
   # non-dirty pages held by db2.
-  sqlite3_release_memory [expr 7*1100]
+  sqlite3_release_memory [expr 7*1132]
   list [nPage db] [nPage db2]
 } {10 3}
 do_test malloc5-6.3.3 {
   # Try to release another 1000 bytes. This should come fromt the db
   # cache, since all three pages held by db2 are either in-use or diry.
   sqlite3_release_memory 1000
   list [nPage db] [nPage db2]
 } {9 3}
 do_test malloc5-6.3.4 {
   # Now release 9900 more (about 9 pages worth). This should expunge
   # the rest of the db cache. But the db2 cache remains intact, because
   # SQLite tries to avoid calling sync().
   if {$::tcl_platform(wordSize)==8} {
-    sqlite3_release_memory 10177
+    sqlite3_release_memory 10500
   } else {
     sqlite3_release_memory 9900
   }
   list [nPage db] [nPage db2]
 } {0 3}
 do_test malloc5-6.3.5 {
   # But if we are really insistent, SQLite will consent to call sync()
   # if there is no other option. UPDATE: As of 3.6.2, SQLite will not
   # call sync() in this scenario. So no further memory can be reclaimed.
   sqlite3_release_memory 1000
   list [nPage db] [nPage db2]
 } {0 3}
 do_test malloc5-6.3.6 {
   # The referenced page (page 1 of the db2 cache) will not be freed no
   # matter how much memory we ask for:
   sqlite3_release_memory 31459
   list [nPage db] [nPage db2]
 } {0 3}
 
 db2 close
 
 sqlite3_soft_heap_limit $::soft_limit
 finish_test
 catch {db close}