Import SQLite 3.10.2.

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 21 matching lines @@
    finish_test
    return
 }
 
 # Skip these tests if OMIT_MEMORY_MANAGEMENT was defined at compile time.
 ifcapable !memorymanage {
    finish_test
    return
 }
 
+test_set_config_pagecache 0 100
+
 sqlite3_soft_heap_limit 0
 sqlite3 db test.db
+db eval {PRAGMA cache_size=1}
 
 do_test malloc5-1.1 {
   # Simplest possible test. Call sqlite3_release_memory when there is exactly
   # one unused page in a single pager cache. The page cannot be freed, as
   # it is dirty. So sqlite3_release_memory() returns 0.
   #
   execsql {
     PRAGMA auto_vacuum=OFF;
     BEGIN;
     CREATE TABLE abc(a, b, c);
   }
   sqlite3_release_memory
 } {0}
 
 do_test malloc5-1.2 {
   # Test that the transaction started in the above test is still active.
   # The lock on the database file should not have been upgraded (this was
   # not the case before version 3.6.2).
   #
   sqlite3 db2 test.db
-  execsql { SELECT * FROM sqlite_master } db2
+  execsql {PRAGMA cache_size=2; SELECT * FROM sqlite_master } db2
 } {}
 do_test malloc5-1.3 {
   # Call [sqlite3_release_memory] when there is exactly one unused page 
   # in the cache belonging to db2.
   #
   set ::pgalloc [sqlite3_release_memory]
-  expr $::pgalloc > 0
-} {1}
+} {0}
+
+# The sizes of memory allocations from system malloc() might vary,
+# depending on the memory allocator algorithms used.  The following
+# routine is designed to support answers that fall within a range
+# of values while also supplying easy-to-understand "expected" values
+# when errors occur.
+#
+proc value_in_range {target x args} {
+  set v [lindex $args 0]
+  if {$v!=""} {
+    if {$v<$target*$x} {return $v}
+    if {$v>$target/$x} {return $v}
+  }
+  return "number between [expr {int($target*$x)}] and [expr {int($target/$x)}]"
+}
+set mrange 0.98   ;#  plus or minus 2%
+
 
 do_test malloc5-1.4 {
   # Commit the transaction and open a new one. Read 1 page into the cache.
   # Because the page is not dirty, it is eligible for collection even
   # before the transaction is concluded.
   #
   execsql {
     COMMIT;
     BEGIN;
     SELECT * FROM abc;
   }
-  sqlite3_release_memory
-} $::pgalloc
+  value_in_range $::pgalloc $::mrange [sqlite3_release_memory]
+} [value_in_range $::pgalloc $::mrange]
 
 do_test malloc5-1.5 {
   # Conclude the transaction opened in the previous [do_test] block. This
   # causes another page (page 1) to become eligible for recycling.
   #
   execsql { COMMIT }
-  sqlite3_release_memory
-} $::pgalloc
+  value_in_range $::pgalloc $::mrange [sqlite3_release_memory]
+} [value_in_range $::pgalloc $::mrange]
 
 do_test malloc5-1.6 {
   # Manipulate the cache so that it contains two unused pages. One requires 
   # a journal-sync to free, the other does not.
   db2 close
   execsql {
     BEGIN;
     SELECT * FROM abc;
     CREATE TABLE def(d, e, f);
   }
-  sqlite3_release_memory 500
-} $::pgalloc
+  value_in_range $::pgalloc $::mrange [sqlite3_release_memory 500]
+} [value_in_range $::pgalloc $::mrange]
 
 do_test malloc5-1.7 {
   # Database should not be locked this time. 
   sqlite3 db2 test.db
   catchsql { SELECT * FROM abc } db2
 } {0 {}}
 do_test malloc5-1.8 {
   # Try to release another block of memory. This will fail as the only
   # pages currently in the cache are dirty (page 3) or pinned (page 1).
   db2 close
@@ skipping 49 matching lines @@
   # called.
   execsql {
     BEGIN;
     SELECT * FROM abc;
   }
   execsql {
     SELECT * FROM sqlite_master;
     BEGIN;
     SELECT * FROM def;
   } db2
-  sqlite3_release_memory
-} [expr $::pgalloc * 2]
+  value_in_range [expr $::pgalloc*2] 0.99 [sqlite3_release_memory]
+} [value_in_range [expr $::pgalloc * 2] 0.99]
 do_test malloc5-3.2 {
   concat \
     [execsql {SELECT * FROM abc; COMMIT}] \
     [execsql {SELECT * FROM def; COMMIT} db2]
 } {1 2 3 4 5 6 7 8 9 10 11 12}
 
 db2 close
 puts "Highwater mark: [sqlite3_memory_highwater]"
 
 # The following two test cases each execute a transaction in which 
@@ skipping 20 matching lines @@
   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 eval {PRAGMA cache_size=1}
   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 <= 110000
 } {1}
 do_test malloc5-4.3 {
@@ skipping 51 matching lines @@
 }
 db close
 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;
+    PRAGMA default_cache_size=2;
   }
   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;
   } 
   forcecopy test.db test2.db
   sqlite3 db2 test2.db
+  db2 eval {PRAGMA cache_size=2}
   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}
+} {2 2}
 
 do_test malloc5-6.2.1 {
   execsql {SELECT * FROM abc} db2
   execsql {SELECT * FROM abc} db
   expr [nPage db] + [nPage db2]
-} {20}
+} {4}
 
 do_test malloc5-6.2.2 {
   # If we now try to reclaim some memory, it should come from the db2 cache.
   sqlite3_release_memory 3000
   expr [nPage db] + [nPage db2]
-} {17}
+} {4}
 do_test malloc5-6.2.3 {
   # Access the db2 cache again, so that all the db2 pages have been used
   # more recently than all the db pages. Then try to reclaim 3000 bytes.
   # This time, 3 pages should be pulled from the db cache.
   execsql { SELECT * FROM abc } db2
   sqlite3_release_memory 3000
   expr [nPage db] + [nPage db2]
-} {17}
+} {4}
 
 do_test malloc5-6.3.1 {
   # Now open a transaction and update 2 pages in the db2 cache. Then
   # do a SELECT on the db cache so that all the db pages are more recently
   # used than the db2 pages. When we try to free memory, SQLite should
   # free the non-dirty db2 pages, then the db pages, then finally use
   # sync() to free up the dirty db2 pages. The only page that cannot be
   # freed is page1 of db2. Because there is an open transaction, the
   # btree layer holds a reference to page 1 in the db2 cache.
   execsql {
     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}
+} {4}
 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*1132]
   list [nPage db] [nPage db2]
-} {10 3}
+} {1 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}
+} {1 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 10500
   } else {
     sqlite3_release_memory 9900
   }
   list [nPage db] [nPage db2]
-} {0 3}
+} {1 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}
+} {1 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}
+} {1 3}
 
 db2 close
 
 sqlite3_soft_heap_limit $::soft_limit
+test_restore_config_pagecache
 finish_test
 catch {db close}