Add //third_party/sqlite to dirs_to_snapshot, remove net_sql.patch

third_party/sqlite/src/test/malloc3.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.
 #
 #***********************************************************************
 #
 # This file contains tests to ensure that the library handles malloc() failures
 # correctly. The emphasis of these tests are the _prepare(), _step() and
 # _finalize() calls.
 #
 # $Id: malloc3.test,v 1.24 2008/10/14 15:54:08 drh Exp $
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 source $testdir/malloc_common.tcl
 
 # Only run these tests if memory debugging is turned on.
 #
 if {!$MEMDEBUG} {
    puts "Skipping malloc3 tests: not compiled with -DSQLITE_MEMDEBUG..."
    finish_test
    return
 }
 
+
+# Do not run these tests with an in-memory journal.
+#
+# In the pager layer, if an IO or OOM error occurs during a ROLLBACK, or
+# when flushing a page to disk due to cache-stress, the pager enters an
+# "error state". The only way out of the error state is to unlock the
+# database file and end the transaction, leaving whatever journal and
+# database files happen to be on disk in place. The next time the current
+# (or any other) connection opens a read transaction, hot-journal rollback
+# is performed if necessary.
+#
+# Of course, this doesn't work with an in-memory journal.
+#
+if {[permutation]=="inmemory_journal"} {
+  finish_test
+  return
+}
+
 #--------------------------------------------------------------------------
 # NOTES ON RECOVERING FROM A MALLOC FAILURE
 # 
 # The tests in this file test the behaviours described in the following
 # paragraphs. These tests test the behaviour of the system when malloc() fails
 # inside of a call to _prepare(), _step(), _finalize() or _reset(). The
 # handling of malloc() failures within ancillary procedures is tested
 # elsewhere.
 #
 # Overview:
@@ skipping 100 matching lines @@
 # * If a PREP block starts a transaction, it must finish it.
 # * A PREP block may not close a transaction it did not start.
 #
 #--------------------------------------------------------------------------
 
 
 # These procs are used to build up a "program" in global variable
 # ::run_test_script. At the end of this file, the proc [run_test] is used
 # to execute the program (and all test cases contained therein).
 #
+set ::run_test_sql_id 0
 set ::run_test_script [list]
 proc TEST {id t} {lappend ::run_test_script -test [list $id $t]}
 proc PREP {p} {lappend ::run_test_script -prep [string trim $p]}
 proc DEBUG {s} {lappend ::run_test_script -debug $s}
 
 # SQL --
 #
 #     SQL ?-norollback? <sql-text>
 #
 # Add an 'SQL' primitive to the program (see notes above). If the -norollback
 # switch is present, then the statement is not allowed to automatically roll
 # back any active transaction if malloc() fails. It must rollback the statement
 # transaction only.
 #
 proc SQL  {a1 {a2 ""}} {
-  # An SQL primitive parameter is a list of two elements, a boolean value
-  # indicating if the statement may cause transaction rollback when malloc()
-  # fails, and the sql statement itself.
+  # An SQL primitive parameter is a list of three elements, an id, a boolean
+  # value indicating if the statement may cause transaction rollback when
+  # malloc() fails, and the sql statement itself.
+  set id [incr ::run_test_sql_id]
   if {$a2 == ""} {
-    lappend ::run_test_script -sql [list true [string trim $a1]]
+    lappend ::run_test_script -sql [list $id true [string trim $a1]]
   } else {
-    lappend ::run_test_script -sql [list false [string trim $a2]]
+    lappend ::run_test_script -sql [list $id false [string trim $a2]]
   }
 }
 
 # TEST_AUTOCOMMIT --
 # 
 #     A shorthand test to see if a transaction is active or not. The first
 #     argument - $id - is the integer number of the test case. The second
 #     argument is either 1 or 0, the expected value of the auto-commit flag.
 #
 proc TEST_AUTOCOMMIT {id a} {
@@ skipping 69 matching lines @@
     execsql {
       SELECT name, tbl_name FROM sqlite_master ORDER BY name;
       SELECT * FROM abc;
     }
   } {abc abc abc_i abc abc_t abc abc_v abc_v 1 2 3}
 }
 
 set sql {
   BEGIN;DELETE FROM abc;
 }
-for {set i 1} {$i < 15} {incr i} {
+for {set i 1} {$i < 100} {incr i} {
   set a $i
   set b "String value $i"
   set c [string repeat X $i]
   append sql "INSERT INTO abc VALUES ($a, '$b', '$c');"
 }
 append sql {COMMIT;}
 PREP $sql
 
 SQL {
   DELETE FROM abc WHERE oid IN (SELECT oid FROM abc ORDER BY random() LIMIT 5);
@@ skipping 184 matching lines @@
 TEST 29 {
   do_test $testid {
     execsql {
       SELECT * FROM v1 WHERE d = g;
     }
   } {a b c a b c 1 2 3 1 2 3}
 }
 
 # Test a simple multi-file transaction 
 #
-file delete -force test2.db
+forcedelete test2.db
 ifcapable attach {
   SQL {ATTACH 'test2.db' AS aux;}
   SQL {BEGIN}
   SQL {CREATE TABLE aux.tbl2(x, y, z)}
   SQL {INSERT INTO tbl2 VALUES(1, 2, 3)}
   SQL {INSERT INTO def VALUES(4, 5, 6)}
   TEST 30 {
     do_test $testid {
       execsql {
         SELECT * FROM tbl2, def WHERE d = x;
@@ skipping 45 matching lines @@
 #
 # End of test program declaration
 #--------------------------------------------------------------------------
 
 proc run_test {arglist iRepeat {pcstart 0} {iFailStart 1}} {
   if {[llength $arglist] %2} {
     error "Uneven number of arguments to TEST"
   }
 
   for {set i 0} {$i < $pcstart} {incr i} {
-    set k2 [lindex $arglist [expr 2 * $i]]
-    set v2 [lindex $arglist [expr 2 * $i + 1]]
+    set k2 [lindex $arglist [expr {2 * $i}]]
+    set v2 [lindex $arglist [expr {2 * $i + 1}]]
     set ac [sqlite3_get_autocommit $::DB]        ;# Auto-Commit
     switch -- $k2 {
-      -sql  {db eval [lindex $v2 1]}
+      -sql  {db eval [lindex $v2 2]}
       -prep {db eval $v2}
+      -debug {eval $v2}
     }
     set nac [sqlite3_get_autocommit $::DB]       ;# New Auto-Commit 
     if {$ac && !$nac} {set begin_pc $i}
   }
 
   db rollback_hook [list incr ::rollback_hook_count]
 
   set iFail $iFailStart
   set pc $pcstart
   while {$pc*2 < [llength $arglist]} {
+    # Fetch the current instruction type and payload.
+    set k [lindex $arglist [expr {2 * $pc}]]
+    set v [lindex $arglist [expr {2 * $pc + 1}]]
 
     # Id of this iteration:
-    set k [lindex $arglist [expr 2 * $pc]]
     set iterid "pc=$pc.iFail=$iFail$k"
-    set v [lindex $arglist [expr 2 * $pc + 1]]
 
     switch -- $k {
 
       -test { 
         foreach {id script} $v {}
+        set testid "malloc3-(test $id).$iterid"
+        eval $script
         incr pc
       }
 
       -sql {
         set ::rollback_hook_count 0
 
+        set id [lindex $v 0]
+        set testid "malloc3-(integrity $id).$iterid"
+
         set ac [sqlite3_get_autocommit $::DB]        ;# Auto-Commit
         sqlite3_memdebug_fail $iFail -repeat 0
-        set rc [catch {db eval [lindex $v 1]} msg]   ;# True error occurs
+        set rc [catch {db eval [lindex $v 2]} msg]   ;# True error occurs
         set nac [sqlite3_get_autocommit $::DB]       ;# New Auto-Commit 
 
         if {$rc != 0 && $nac && !$ac} {
           # Before [db eval] the auto-commit flag was clear. Now it
-          # is set. Since an error occured we assume this was not a
-          # commit - therefore a rollback occured. Check that the
+          # is set. Since an error occurred we assume this was not a
+          # commit - therefore a rollback occurred. Check that the
           # rollback-hook was invoked.
-          do_test malloc3-rollback_hook.$iterid {
+          do_test malloc3-rollback_hook_count.$iterid {
             set ::rollback_hook_count
           } {1}
         }
 
         set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
         if {$rc == 0} {
             # Successful execution of sql. The number of failed malloc()
             # calls should be equal to the number of benign failures.
             # Otherwise a malloc() failed and the error was not reported.
             # 
-            if {$nFail!=$nBenign} {
-              error "Unreported malloc() failure"
+            set expr {$nFail!=$nBenign}
+            if {[expr $expr]} {
+              error "Unreported malloc() failure, test \"$testid\", $expr"
             }
 
             if {$ac && !$nac} {
               # Before the [db eval] the auto-commit flag was set, now it
               # is clear. We can deduce that a "BEGIN" statement has just
               # been successfully executed.
               set begin_pc $pc
             } 
 
             incr pc
             set iFail 1
-            integrity_check "malloc3-(integrity).$iterid"
+            integrity_check $testid
         } elseif {[regexp {.*out of memory} $msg] || [db errorcode] == 3082} {
             # Out of memory error, as expected.
             #
-            integrity_check "malloc3-(integrity).$iterid"
+            integrity_check $testid
             incr iFail
             if {$nac && !$ac} {
-
-              if {![lindex $v 0] && [db errorcode] != 3082} {
-                # error "Statement \"[lindex $v 1]\" caused a rollback"
+              if {![lindex $v 1] && [db errorcode] != 3082} {
+                # error "Statement \"[lindex $v 2]\" caused a rollback"
               }
 
               for {set i $begin_pc} {$i < $pc} {incr i} {
-                set k2 [lindex $arglist [expr 2 * $i]]
-                set v2 [lindex $arglist [expr 2 * $i + 1]]
+                set k2 [lindex $arglist [expr {2 * $i}]]
+                set v2 [lindex $arglist [expr {2 * $i + 1}]]
                 set catchupsql ""
                 switch -- $k2 {
-                  -sql  {set catchupsql [lindex $v2 1]}
+                  -sql  {set catchupsql [lindex $v2 2]}
                   -prep {set catchupsql $v2}
                 }
                 db eval $catchupsql
               }
             }
         } else {
             error $msg
         }
 
-        while {[lindex $arglist [expr 2 * ($pc -1)]] == "-test"} {
+        # back up to the previous "-test" block.
+        while {[lindex $arglist [expr {2 * ($pc - 1)}]] == "-test"} {
           incr pc -1
         }
       }
 
       -prep {
         db eval $v
         incr pc
       }
 
       -debug {
         eval $v
         incr pc
       }
 
       default { error "Unknown switch: $k" }
     }
   }
 }
 
-# Turn of the Tcl interface's prepared statement caching facility. Then
+# Turn off the Tcl interface's prepared statement caching facility. Then
 # run the tests with "persistent" malloc failures.
 sqlite3_extended_result_codes db 1
 db cache size 0
 run_test $::run_test_script 1
 
 # Close and reopen the db.
 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
 sqlite3 db test.db
 sqlite3_extended_result_codes db 1
 set ::DB [sqlite3_connection_pointer db]
 
 # Turn off the Tcl interface's prepared statement caching facility in
 # the new connnection. Then run the tests with "transient" malloc failures.
 db cache size 0
 run_test $::run_test_script 0
 
 sqlite3_memdebug_fail -1
 finish_test