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

third_party/sqlite/src/test/malloc.test

 # 2001 September 15
 #
 # 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 attempts to check the behavior of the SQLite library in 
 # an out-of-memory situation. When compiled with -DSQLITE_DEBUG=1, 
 # the SQLite library accepts a special command (sqlite3_memdebug_fail N C)
 # which causes the N-th malloc to fail.  This special feature is used
 # to see what happens in the library if a malloc were to really fail
 # due to an out-of-memory situation.
 #
 # $Id: malloc.test,v 1.81 2009/06/24 13:13:45 drh Exp $
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
+set ::testprefix malloc
 
 
 # Only run these tests if memory debugging is turned on.
 #
 source $testdir/malloc_common.tcl
 if {!$MEMDEBUG} {
    puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
    finish_test
    return
 }
@@ skipping 230 matching lines @@
   INSERT INTO abc1 VALUES(1, 2, 3);
   INSERT INTO abc2 VALUES(1, 2, 3);
   COMMIT;
 }
 
 # This block tests malloc() failures that occur while opening a 
 # connection to a database.
 do_malloc_test 10 -tclprep {
   catch {db2 close}
   db close
-  file delete -force test.db test.db-journal
+  forcedelete test.db test.db-journal
   sqlite3 db test.db
   sqlite3_extended_result_codes db 1
   db eval {CREATE TABLE abc(a, b, c)}
 } -tclbody {
   db close
   sqlite3 db2 test.db
   sqlite3_extended_result_codes db2 1
   db2 eval {SELECT * FROM sqlite_master}
   db2 close
 }
@@ skipping 50 matching lines @@
     sqlite3 db2 test2.db
     sqlite3_extended_result_codes db2 1
     db2 eval {
       PRAGMA journal_mode = DELETE;    /* For inmemory_journal permutation */
       PRAGMA synchronous = 0;
       CREATE TABLE t1(a, b);
       INSERT INTO t1 VALUES(1, 2);
       BEGIN;
       INSERT INTO t1 VALUES(3, 4);
     }
-    copy_file test2.db test.db
-    copy_file test2.db-journal test.db-journal
+    forcecopy test2.db test.db
+    forcecopy test2.db-journal test.db-journal
     db2 close
   } -tclbody {
     sqlite3 db test.db
     sqlite3_extended_result_codes db 1
 
     # If an out-of-memory occurs within a call to a VFS layer function during
     # hot-journal rollback, sqlite will report SQLITE_CORRUPT. See commit
     # [5668] for details.
     set rc [catch {db eval { SELECT * FROM t1 }} msg]
     if {$msg eq "database disk image is malformed"} { set msg "out of memory" }
@@ skipping 136 matching lines @@
   }
 }
 unset static_string
 
 # Make sure SQLITE_NOMEM is reported out on an ATTACH failure even
 # when the malloc failure occurs within the nested parse.
 #
 ifcapable attach {
   do_malloc_test 20 -tclprep {
     db close
-    file delete -force test2.db test2.db-journal
+    forcedelete test2.db test2.db-journal
     sqlite3 db test2.db
     sqlite3_extended_result_codes db 1
     db eval {CREATE TABLE t1(x);}
     db close
   } -tclbody {
     if {[catch {sqlite3 db test.db}]} {
       error "out of memory"
     }
     sqlite3_extended_result_codes db 1
   } -sqlbody {
@@ skipping 322 matching lines @@
 }
 
 do_malloc_test 36 -sqlprep {
   CREATE TABLE t1(a, b);
   INSERT INTO t1 VALUES(1, 2);
   INSERT INTO t1 VALUES(3, 4);
 } -sqlbody {
   SELECT test_agg_errmsg16(), group_concat(a) FROM t1
 }
 
-# At one point, if an OOM occured immediately after obtaining a shared lock
+# At one point, if an OOM occurred immediately after obtaining a shared lock
 # on the database file, the file remained locked. This test case ensures
 # that bug has been fixed.i
 if {[db eval {PRAGMA locking_mode}]!="exclusive"} {
   do_malloc_test 37 -tclprep {
     sqlite3 db2 test.db
     execsql {
       CREATE TABLE t1(a, b);
       INSERT INTO t1 VALUES(1, 2);
     } db2
   } -sqlbody {
     SELECT * FROM t1;
   } -cleanup {
     # Try to write to the database using connection [db2]. If connection [db]
     # has correctly released the shared lock, this write attempt should 
     # succeed. If [db] has not released the lock, this should hit an 
     # SQLITE_BUSY error.
     do_test malloc-36.$zRepeat.${::n}.unlocked {
       execsql {INSERT INTO t1 VALUES(3, 4)} db2
     } {}
     db2 close
   }
   catch { db2 close }
 }
 
-ifcapable stat2&&utf16 {
-  do_malloc_test 38 -tclprep {
-    add_test_collate db 0 0 1
-    execsql {
-      ANALYZE;
-      CREATE TABLE t4(x COLLATE test_collate);
-      CREATE INDEX t4x ON t4(x);
-      INSERT INTO sqlite_stat2 VALUES('t4', 't4x', 0, 'aaa');
-      INSERT INTO sqlite_stat2 VALUES('t4', 't4x', 1, 'aaa');
-      INSERT INTO sqlite_stat2 VALUES('t4', 't4x', 2, 'aaa');
-      INSERT INTO sqlite_stat2 VALUES('t4', 't4x', 3, 'aaa');
-      INSERT INTO sqlite_stat2 VALUES('t4', 't4x', 4, 'aaa');
-      INSERT INTO sqlite_stat2 VALUES('t4', 't4x', 5, 'aaa');
-      INSERT INTO sqlite_stat2 VALUES('t4', 't4x', 6, 'aaa');
-      INSERT INTO sqlite_stat2 VALUES('t4', 't4x', 7, 'aaa');
-      INSERT INTO sqlite_stat2 VALUES('t4', 't4x', 8, 'aaa');
-      INSERT INTO sqlite_stat2 VALUES('t4', 't4x', 9, 'aaa');
-    }
-    db close
-    sqlite3 db test.db
-    sqlite3_db_config_lookaside db 0 0 0
-    add_test_collate db 0 0 1
-  } -sqlbody {
-    SELECT * FROM t4 AS t41, t4 AS t42 WHERE t41.x>'ddd' AND t42.x>'ccc'
+
+# Test that if an OOM error occurs, aux-data is still correctly destroyed.
+# This test case was causing either a memory-leak or an assert() failure
+# at one point, depending on the configuration.
+#
+do_malloc_test 39 -tclprep {
+  sqlite3 db test.db
+} -sqlbody {
+  SELECT test_auxdata('abc', 'def');
+} -cleanup {
+  db close
+}
+
+reset_db
+add_test_utf16bin_collate db
+do_execsql_test 40.1 {
+  CREATE TABLE t1(a);
+  INSERT INTO t1 VALUES('fghij');
+  INSERT INTO t1 VALUES('pqrst');
+  INSERT INTO t1 VALUES('abcde');
+  INSERT INTO t1 VALUES('uvwxy');
+  INSERT INTO t1 VALUES('klmno');
+}
+do_execsql_test 40.2 {
+  SELECT * FROM t1 ORDER BY 1 COLLATE utf16bin;
+} {abcde fghij klmno pqrst uvwxy}
+do_faultsim_test 40.3 -faults oom-trans* -body {
+  execsql {
+    SELECT * FROM t1 ORDER BY 1 COLLATE utf16bin;
   }
+} -test {
+  faultsim_test_result {0 {abcde fghij klmno pqrst uvwxy}} 
+  faultsim_integrity_check
+}
+
+reset_db
+add_test_utf16bin_collate db
+set big [string repeat x 200]
+do_execsql_test 41.1 {
+  DROP TABLE IF EXISTS t1;
+  CREATE TABLE t1(a COLLATE utf16bin);
+  INSERT INTO t1 VALUES('fghij' || $::big);
+  INSERT INTO t1 VALUES('pqrst' || $::big);
+  INSERT INTO t1 VALUES('abcde' || $::big);
+  INSERT INTO t1 VALUES('uvwxy' || $::big);
+  INSERT INTO t1 VALUES('klmno' || $::big);
+  CREATE INDEX i1 ON t1(a);
+}
+do_faultsim_test 41.2 -faults oom* -body {
+  execsql { SELECT * FROM t1 WHERE a = ('abcde' || $::big)}
+} -test {
+  faultsim_test_result [list 0 "abcde$::big"]
+  faultsim_integrity_check
 }
 
 # Ensure that no file descriptors were leaked.
 do_test malloc-99.X {
   catch {db close}
   set sqlite_open_file_count
 } {0}
 
 puts open-file-count=$sqlite_open_file_count
 finish_test