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

third_party/sqlite/src/test/wal3.test

 # 2010 April 13
 #
 # 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 76 matching lines @@
   do_test wal3-1.$i.3 {
     execsql { SELECT x FROM t1 WHERE rowid = $i }
   } $str
   do_test wal3-1.$i.4 {
     execsql { PRAGMA integrity_check } db2
   } {ok}
   db2 close
   
   # Check that the file-system in its current state can be recovered.
   # 
-  file copy -force test.db test2.db
-  file copy -force test.db-wal test2.db-wal
-  file delete -force test2.db-journal
+  forcecopy test.db test2.db
+  forcecopy test.db-wal test2.db-wal
+  forcedelete test2.db-journal
   sqlite3 db2 test2.db
   do_test wal3-1.$i.5 {
     execsql { SELECT count(*) FROM t1 } db2
   } 4018
   do_test wal3-1.$i.6 {
     execsql { SELECT x FROM t1 WHERE rowid = $i }
   } $str
   do_test wal3-1.$i.7 {
     execsql { PRAGMA integrity_check } db2
   } {ok}
@@ skipping 91 matching lines @@
     {test.db-wal normal test.db normal}
   3 full    
     {test.db-wal normal test.db-wal normal test.db-wal normal test.db normal}
 } {
 
   proc sync_counter {args} { 
     foreach {method filename id flags} $args break
     lappend ::syncs [file tail $filename] $flags
   }
   do_test wal3-3.$tn {
-    file delete -force test.db test.db-wal test.db-journal
+    forcedelete test.db test.db-wal test.db-journal
   
     testvfs T
     T filter {} 
     T script sync_counter
     sqlite3 db test.db -vfs T
   
     execsql "PRAGMA synchronous = $syncmode"
     execsql { PRAGMA journal_mode = WAL }
+    execsql { CREATE TABLE filler(a,b,c); }
 
     set ::syncs [list]
     T filter xSync
     execsql {
       CREATE TABLE x(y);
       INSERT INTO x VALUES('z');
       PRAGMA wal_checkpoint;
     }
     T filter {}
     set ::syncs
@@ skipping 174 matching lines @@
 #     acquire a different read-lock (not aReadMark[0]) and read the new
 #     snapshot.
 #
 #   + The attempt to obtain the lock on aReadMark[0] fails with SQLITE_BUSY.
 #     This can happen if a checkpoint is ongoing. In this case also simply
 #     obtain a different read-lock.
 #
 catch {db close}
 testvfs T -default 1
 do_test wal3-6.1.1 {
-  file delete -force test.db test.db-journal test.db wal
+  forcedelete test.db test.db-journal test.db wal
   sqlite3 db test.db
   execsql { PRAGMA auto_vacuum = off }
   execsql { PRAGMA journal_mode = WAL }
   execsql {
     CREATE TABLE t1(a, b);
     INSERT INTO t1 VALUES('o', 't');
     INSERT INTO t1 VALUES('t', 'f');
   }
 } {}
 do_test wal3-6.1.2 {
   sqlite3 db2 test.db
   sqlite3 db3 test.db
   execsql { BEGIN ; SELECT * FROM t1 } db3
 } {o t t f}
 do_test wal3-6.1.3 {
   execsql { PRAGMA wal_checkpoint } db2
-} {0 7 7}
+} {0 4 4}
 
 # At this point the log file has been fully checkpointed. However, 
 # connection [db3] holds a lock that prevents the log from being wrapped.
 # Test case 3.6.1.4 has [db] attempt a read-lock on aReadMark[0]. But
 # as it is obtaining the lock, [db2] appends to the log file.
 #
 T filter xShmLock
 T script lock_callback
 proc lock_callback {method file handle spec} {
   if {$spec == "3 1 lock shared"} {
@@ skipping 43 matching lines @@
   db2 eval { INSERT INTO t1 VALUES('n', 't') }
   set sz2 [file size test.db-wal]
   expr {$sz2==$sz1}
 } {1}
 
 db3 close
 db2 close
 db close
 
 do_test wal3-6.2.1 {
-  file delete -force test.db test.db-journal test.db wal
+  forcedelete test.db test.db-journal test.db wal
   sqlite3 db test.db
   sqlite3 db2 test.db
   execsql { PRAGMA auto_vacuum = off }
   execsql { PRAGMA journal_mode = WAL }
   execsql {
     CREATE TABLE t1(a, b);
     INSERT INTO t1 VALUES('h', 'h');
     INSERT INTO t1 VALUES('l', 'b');
   }
 } {}
 
 T filter xShmLock
 T script lock_callback
 proc lock_callback {method file handle spec} {
   if {$spec == "3 1 unlock exclusive"} {
     T filter {}
     set ::R [db2 eval {
       BEGIN;
       SELECT * FROM t1;
     }]
   }
 }
 do_test wal3-6.2.2 {
   execsql { PRAGMA wal_checkpoint }
-} {0 7 7}
+} {0 4 4}
 do_test wal3-6.2.3 {
   set ::R
 } {h h l b}
 do_test wal3-6.2.4 {
   set sz1 [file size test.db-wal]
   execsql { INSERT INTO t1 VALUES('b', 'c'); }
   set sz2 [file size test.db-wal]
   expr {$sz2 > $sz1}
 } {1}
 do_test wal3-6.2.5 {
@@ skipping 20 matching lines @@
 #     written to the log. In this case the reader should re-read the 
 #     wal-index header and lock a snapshot corresponding to the new 
 #     header.
 #
 #   + The value in the aReadMark[x] slot has been modified since it was
 #     read.
 #
 catch {db close}
 testvfs T -default 1
 do_test wal3-7.1.1 {
-  file delete -force test.db test.db-journal test.db wal
+  forcedelete test.db test.db-journal test.db wal
   sqlite3 db test.db
   execsql {
     PRAGMA journal_mode = WAL;
     CREATE TABLE blue(red PRIMARY KEY, green);
   }
 } {wal}
 
 T script method_callback
 T filter xOpen
 proc method_callback {method args} {
@@ skipping 36 matching lines @@
   set ::locks
 } {{5 1 lock shared} {5 1 unlock shared} {4 1 lock shared} {4 1 unlock shared}}
 
 db close
 db2 close
 T delete
 
 #-------------------------------------------------------------------------
 # 
 do_test wal3-8.1 {
-  file delete -force test.db test.db-journal test.db wal
+  forcedelete test.db test.db-journal test.db wal
   sqlite3 db test.db
   sqlite3 db2 test.db
   execsql {
     PRAGMA auto_vacuum = off;
     PRAGMA journal_mode = WAL;
     CREATE TABLE b(c);
     INSERT INTO b VALUES('Tehran');
     INSERT INTO b VALUES('Qom');
     INSERT INTO b VALUES('Markazi');
     PRAGMA wal_checkpoint;
   }
-} {wal 0 9 9}
+} {wal 0 5 5}
 do_test wal3-8.2 {
   execsql { SELECT * FROM b }
 } {Tehran Qom Markazi}
 do_test wal3-8.3 {
   db eval { SELECT * FROM b } {
     db eval { INSERT INTO b VALUES('Qazvin') }
     set r [db2 eval { SELECT * FROM b }]
     break
   }
   set r
 } {Tehran Qom Markazi Qazvin}
 do_test wal3-8.4 {
   execsql {
     INSERT INTO b VALUES('Gilan');
     INSERT INTO b VALUES('Ardabil');
   }
 } {}
 db2 close
 
 faultsim_save_and_close
 testvfs T -default 1
 faultsim_restore_and_reopen
 T filter xShmLock
 T script lock_callback
 
 proc lock_callback {method file handle spec} {
-  if {$spec == "4 1 unlock exclusive"} {
+  if {$spec == "1 7 unlock exclusive"} {
     T filter {}
     set ::r [catchsql { SELECT * FROM b } db2]
   }
 }
 sqlite3 db test.db
 sqlite3 db2 test.db
 do_test wal3-8.5 {
   execsql { SELECT * FROM b }
 } {Tehran Qom Markazi Qazvin Gilan Ardabil}
 do_test wal3-8.6 {
@@ skipping 32 matching lines @@
 # exclusive lock on an aReadMark[] slot for the purposes of modifying
 # the value, then drops back to a shared-lock for the duration of the
 # transaction.
 #
 # This test case verifies that if an exclusive lock cannot be obtained
 # on any aReadMark[] slot (because there are already several readers),
 # the client takes a shared-lock on a slot without modifying the value
 # and continues.
 #
 set nConn 50
-if { [string match *BSD $tcl_platform(os)] } { set nConn 35 }
+if { [string match *BSD $tcl_platform(os)] } { set nConn 25 }
 do_test wal3-9.0 {
-  file delete -force test.db test.db-journal test.db wal
+  forcedelete test.db test.db-journal test.db wal
   sqlite3 db test.db
   execsql {
     PRAGMA page_size = 1024;
     PRAGMA journal_mode = WAL;
     CREATE TABLE whoami(x);
     INSERT INTO whoami VALUES('nobody');
   }
 } {wal}
 for {set i 0} {$i < $nConn} {incr i} {
   set c db$i
@@ skipping 54 matching lines @@
 
     expr {[file size test.db-wal] > [expr 1032*9000]}
   } 1
 
   do_test wal3-10.$tn.2 {
     sql2 {PRAGMA integrity_check}
   } {ok}
 }
 
 finish_test
-