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

third_party/sqlite/src/test/wal2.test

 # 2010 May 5
 #
 # 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 implements regression tests for SQLite library.  The
 # focus of this file is testing the operation of the library in
 # "PRAGMA journal_mode=WAL" mode.
 #
 
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 source $testdir/lock_common.tcl
 source $testdir/malloc_common.tcl
 source $testdir/wal_common.tcl
 
 set testprefix wal2
 
 ifcapable !wal {finish_test ; return }
 
+set sqlite_sync_count 0
+proc cond_incr_sync_count {adj} {
+  global sqlite_sync_count
+  if {$::tcl_platform(platform) == "windows"} {
+    incr sqlite_sync_count $adj
+  } {
+    ifcapable !dirsync {
+      incr sqlite_sync_count $adj
+    }
+  }
+}
+
 proc set_tvfs_hdr {file args} {
 
   # Set $nHdr to the number of bytes in the wal-index header:
   set nHdr 48
   set nInt [expr {$nHdr/4}]
 
   if {[llength $args]>2} {
     error {wrong # args: should be "set_tvfs_hdr fileName ?val1? ?val2?"}
   }
 
   set blob [tvfs shm $file]
+  if {$::tcl_platform(byteOrder)=="bigEndian"} {set fmt I} {set fmt i}
 
   if {[llength $args]} {
     set ia [lindex $args 0]
     set ib $ia
     if {[llength $args]==2} {
       set ib [lindex $args 1]
     }
     binary scan $blob a[expr $nHdr*2]a* dummy tail
-    set blob [binary format i${nInt}i${nInt}a* $ia $ib $tail]
+    set blob [binary format ${fmt}${nInt}${fmt}${nInt}a* $ia $ib $tail]
     tvfs shm $file $blob
   }
 
-  binary scan $blob i${nInt} ints
+  binary scan $blob ${fmt}${nInt} ints
   return $ints
 }
 
 proc incr_tvfs_hdr {file idx incrval} {
   set ints [set_tvfs_hdr $file]
   set v [lindex $ints $idx]
   incr v $incrval
   lset ints $idx $v
   set_tvfs_hdr $file $ints
 }
 
 
 #-------------------------------------------------------------------------
 # Test case wal2-1.*:
 #
 # Set up a small database containing a single table. The database is not
 # checkpointed during the test - all content resides in the log file.
 #
 # Two connections are established to the database file - a writer ([db])
 # and a reader ([db2]). For each of the 8 integer fields in the wal-index
 # header (6 fields and 2 checksum values), do the following:
 #
 #   1. Modify the database using the writer.
 #
 #   2. Attempt to read the database using the reader. Before the reader
 #      has a chance to snapshot the wal-index header, increment one
-#      of the the integer fields (so that the reader ends up with a corrupted
+#      of the integer fields (so that the reader ends up with a corrupted
 #      header).
 #
 #   3. Check that the reader recovers the wal-index and reads the correct
 #      database content.
 #
 do_test wal2-1.0 {
   proc tvfs_cb {method filename args} { 
     set ::filename $filename
     return SQLITE_OK 
   }
@@ skipping 19 matching lines @@
 } {4 10}
 do_test wal2-1.1 {
   execsql { SELECT count(a), sum(a) FROM t1 } db2
 } {4 10}
 
 set RECOVER [list                                      \
   {0 1 lock exclusive}   {1 7 lock exclusive}          \
   {1 7 unlock exclusive} {0 1 unlock exclusive}        \
 ]
 set READ [list                                         \
+  {4 1 lock shared}    {4 1 unlock shared}             \
+]
+set INITSLOT [list                                     \
   {4 1 lock exclusive} {4 1 unlock exclusive}          \
-  {4 1 lock shared}    {4 1 unlock shared}             \
 ]
 
 foreach {tn iInsert res wal_index_hdr_mod wal_locks} "
          2    5   {5 15}    0             {$RECOVER $READ}
          3    6   {6 21}    1             {$RECOVER $READ}
          4    7   {7 28}    2             {$RECOVER $READ}
          5    8   {8 36}    3             {$RECOVER $READ}
          6    9   {9 45}    4             {$RECOVER $READ}
          7   10   {10 55}   5             {$RECOVER $READ}
          8   11   {11 66}   6             {$RECOVER $READ}
          9   12   {12 78}   7             {$RECOVER $READ}
         10   13   {13 91}   8             {$RECOVER $READ}
         11   14   {14 105}  9             {$RECOVER $READ}
-        12   15   {15 120}  -1            {$READ}
+        12   15   {15 120}  -1            {$INITSLOT $READ}
 " {
 
   do_test wal2-1.$tn.1 {
     execsql { INSERT INTO t1 VALUES($iInsert) }
     set ::locks [list]
     proc tvfs_cb {method args} {
       lappend ::locks [lindex $args 2]
       return SQLITE_OK
     }
     tvfs filter xShmLock
     if {$::wal_index_hdr_mod >= 0} {
       incr_tvfs_hdr $::filename $::wal_index_hdr_mod 1
     }
     execsql { SELECT count(a), sum(a) FROM t1 } db2
   } $res
 
   do_test wal2-1.$tn.2 {
     set ::locks
   } $wal_locks
 }
 db close
 db2 close
 tvfs delete
-file delete -force test.db test.db-wal test.db-journal
+forcedelete test.db test.db-wal test.db-journal
 
 #-------------------------------------------------------------------------
 # This test case is very similar to the previous one, except, after
 # the reader reads the corrupt wal-index header, but before it has
 # a chance to re-read it under the cover of the RECOVER lock, the
 # wal-index header is replaced with a valid, but out-of-date, header.
 #
 # Because the header checksum looks Ok, the reader does not run recovery,
 # it simply drops back to a READ lock and proceeds. But because the
 # header is out-of-date, the reader reads the out-of-date snapshot.
@@ skipping 86 matching lines @@
 
     if {$::wal_index_hdr_mod >= 0} {
       incr_tvfs_hdr $::filename $::wal_index_hdr_mod 1
     }
     execsql { SELECT count(a), sum(a) FROM t1 } db2
   } $res1
 }
 db close
 db2 close
 tvfs delete
-file delete -force test.db test.db-wal test.db-journal
+forcedelete test.db test.db-wal test.db-journal
 
 
 if 0 {
 #-------------------------------------------------------------------------
 # This test case - wal2-3.* - tests the response of the library to an
 # SQLITE_BUSY when attempting to obtain a READ or RECOVER lock.
 #
 #   wal2-3.0 - 2: SQLITE_BUSY when obtaining a READ lock
 #   wal2-3.3 - 6: SQLITE_BUSY when obtaining a RECOVER lock
 #
@@ skipping 52 matching lines @@
   list [info exists ::sabotage] [info exists ::locked]
 } {1 1}
 do_test wal2-3.4 {
   execsql { SELECT count(a), sum(a) FROM t1 }
 } {4 10}
 do_test wal2-3.5 {
   list [info exists ::sabotage] [info exists ::locked]
 } {0 0}
 db close
 tvfs delete
-file delete -force test.db test.db-wal test.db-journal
+forcedelete test.db test.db-wal test.db-journal
 
 }
 
 #-------------------------------------------------------------------------
 # Test that a database connection using a VFS that does not support the
 # xShmXXX interfaces cannot open a WAL database.
 #
 do_test wal2-4.1 {
   sqlite3 db test.db
   execsql {
     PRAGMA auto_vacuum = 0;
     PRAGMA journal_mode = WAL;
     CREATE TABLE data(x);
     INSERT INTO data VALUES('need xShmOpen to see this');
     PRAGMA wal_checkpoint;
   }
-} {wal 0 5 5}
+  # Three pages in the WAL file at this point: One copy of page 1 and two
+  # of the root page for table "data".
+} {wal 0 3 3}
 do_test wal2-4.2 {
   db close
   testvfs tvfs -noshm 1
   sqlite3 db test.db -vfs tvfs
   catchsql { SELECT * FROM data }
 } {1 {unable to open database file}}
 do_test wal2-4.3 {
   db close
   testvfs tvfs
   sqlite3 db test.db -vfs tvfs
@@ skipping 59 matching lines @@
 #   wal2-6.4.*: Check that xShmLock calls are omitted in exclusive locking
 #               mode.
 #
 #   wal2-6.5.*: 
 #
 #   wal2-6.6.*: Check that if the xShmLock() to reaquire a WAL read-lock when
 #               exiting exclusive mode fails (i.e. SQLITE_IOERR), then the
 #               connection silently remains in exclusive mode.
 #
 do_test wal2-6.1.1 {
-  file delete -force test.db test.db-wal test.db-journal
+  forcedelete test.db test.db-wal test.db-journal
   sqlite3 db test.db
   execsql {
     Pragma Journal_Mode = Wal;
   }
 } {wal}
 do_test wal2-6.1.2 {
   execsql { PRAGMA lock_status }
 } {main unlocked temp closed}
 do_test wal2-6.1.3 {
   execsql {
@@ skipping 22 matching lines @@
 } {1 2 main shared temp closed}
 do_test wal2-6.1.6 {
   execsql {
     INSERT INTO t1 VALUES(3, 4);
     PRAGMA lock_status;
   }
 } {main shared temp closed}
 db close
 
 do_test wal2-6.2.1 {
-  file delete -force test.db test.db-wal test.db-journal
+  forcedelete test.db test.db-wal test.db-journal
   sqlite3 db test.db
   execsql {
     Pragma Locking_Mode = Exclusive;
     Pragma Journal_Mode = Wal;
     Pragma Lock_Status;
   }
 } {exclusive wal main exclusive temp closed}
 do_test wal2-6.2.2 {
   execsql {
     BEGIN;
@@ skipping 47 matching lines @@
 do_test wal2-6.2.9 {
   execsql {
     INSERT INTO t1 VALUES(5, 6);
     SELECT * FROM t1;
     pragma lock_status;
   }
 } {1 2 3 4 5 6 main shared temp closed}
 db close
 
 do_test wal2-6.3.1 {
-  file delete -force test.db test.db-wal test.db-journal
+  forcedelete test.db test.db-wal test.db-journal
   sqlite3 db test.db
   execsql {
     PRAGMA journal_mode = WAL;
     PRAGMA locking_mode = exclusive;
     BEGIN;
       CREATE TABLE t1(x);
       INSERT INTO t1 VALUES('Chico');
       INSERT INTO t1 VALUES('Harpo');
     COMMIT;
   }
@@ skipping 24 matching lines @@
   execsql { PRAGMA lock_status }
 } {main exclusive temp closed}
 db close
 
 
 # This test - wal2-6.4.* - uses a single database connection and the
 # [testvfs] instrumentation to test that xShmLock() is being called
 # as expected when a WAL database is used with locking_mode=exclusive.
 #
 do_test wal2-6.4.1 {
-  file delete -force test.db test.db-wal test.db-journal
+  forcedelete test.db test.db-wal test.db-journal
   proc tvfs_cb {method args} {
     set ::shm_file [lindex $args 0]
     if {$method == "xShmLock"} { lappend ::locks [lindex $args 2] }
     return "SQLITE_OK"
   }
   testvfs tvfs
   tvfs script tvfs_cb
   sqlite3 db test.db -vfs tvfs
+  set {} {}
 } {}
 
 set RECOVERY {
   {0 1 lock exclusive} {1 7 lock exclusive} 
   {1 7 unlock exclusive} {0 1 unlock exclusive}
 }
 set READMARK0_READ {
   {3 1 lock shared} {3 1 unlock shared}
 }
 set READMARK0_WRITE {
@@ skipping 103 matching lines @@
   sqlite3 db test.db
   execsql {
     PRAGMA auto_vacuum = 0;
     PRAGMA journal_mode = wal;
     PRAGMA locking_mode = exclusive;
     CREATE TABLE t2(a, b);
     PRAGMA wal_checkpoint;
     INSERT INTO t2 VALUES('I', 'II');
     PRAGMA journal_mode;
   }
-} {wal exclusive 0 3 3 wal}
+} {wal exclusive 0 2 2 wal}
 do_test wal2-6.5.2 {
   execsql {
     PRAGMA locking_mode = normal;
     INSERT INTO t2 VALUES('III', 'IV');
     PRAGMA locking_mode = exclusive;
     SELECT * FROM t2;
   }
 } {normal exclusive I II III IV}
 do_test wal2-6.5.3 {
   execsql { PRAGMA wal_checkpoint }
-} {0 4 4}
+} {0 2 2}
 db close
 
 proc lock_control {method filename handle spec} {
   foreach {start n op type} $spec break
   if {$op == "lock"} { return SQLITE_IOERR }
   return SQLITE_OK
 }
 do_test wal2-6.6.1 {
   testvfs T
   T script lock_control
@@ skipping 31 matching lines @@
 } {0 {I II III IV V VI VII VIII IX X}}
 
 db close
 db2 close
 T delete
 
 #-------------------------------------------------------------------------
 # Test a theory about the checksum algorithm. Theory was false and this
 # test did not provoke a bug.
 #
-file delete -force test.db test.db-wal test.db-journal
+forcedelete test.db test.db-wal test.db-journal
 do_test wal2-7.1.1 {
   sqlite3 db test.db
   execsql {
     PRAGMA page_size = 4096;
     PRAGMA journal_mode = WAL;
     CREATE TABLE t1(a, b);
   }
   file size test.db
 } {4096}
 do_test wal2-7.1.2 {
-  file copy -force test.db test2.db
-  file copy -force test.db-wal test2.db-wal
-  hexio_write test2.db-wal 48 FF
+  forcecopy test.db test2.db
+  forcecopy test.db-wal test2.db-wal
+  # The first 32 bytes of the WAL file contain the WAL header. Offset 48
+  # is the first byte of the checksum for the first frame in the WAL. 
+  # The following three lines replaces the contents of that byte with 
+  # a different value.
+  set newval FF
+  if {$newval == [hexio_read test2.db-wal 48 1]} { set newval 00 }
+  hexio_write test2.db-wal 48 $newval
 } {1}
 do_test wal2-7.1.3 {
   sqlite3 db2 test2.db
   execsql { PRAGMA wal_checkpoint } db2
   execsql { SELECT * FROM sqlite_master } db2
 } {}
 db close
 db2 close
-file delete -force test.db test.db-wal test.db-journal
+forcedelete test.db test.db-wal test.db-journal
 do_test wal2-8.1.2 {
   sqlite3 db test.db
   execsql {
     PRAGMA auto_vacuum=OFF;
     PRAGMA page_size = 1024;
     PRAGMA journal_mode = WAL;
     CREATE TABLE t1(x);
     INSERT INTO t1 VALUES(zeroblob(8188*1020));
     CREATE TABLE t2(y);
     PRAGMA wal_checkpoint;
@@ skipping 35 matching lines @@
 # Test that even if the checksums for both are valid, if the two copies
 # of the wal-index header in the wal-index do not match, the client
 # runs (or at least tries to run) database recovery.
 # 
 #
 proc get_name {method args} { set ::filename [lindex $args 0] ; tvfs filter {} }
 testvfs tvfs
 tvfs script get_name
 tvfs filter xShmOpen
 
-file delete -force test.db test.db-wal test.db-journal
+forcedelete test.db test.db-wal test.db-journal
 do_test wal2-9.1 {
   sqlite3 db test.db -vfs tvfs
   execsql {
     PRAGMA journal_mode = WAL;
     CREATE TABLE x(y);
     INSERT INTO x VALUES('Barton');
     INSERT INTO x VALUES('Deakin');
   }
 
   # Set $wih(1) to the contents of the wal-index header after
@@ skipping 148 matching lines @@
 db2 close
 tvfs delete
 
 #-------------------------------------------------------------------------
 # If a connection is required to create a WAL or SHM file, it creates 
 # the new files with the same file-system permissions as the database 
 # file itself. Test this.
 #
 if {$::tcl_platform(platform) == "unix"} {
   faultsim_delete_and_reopen
-  set umask [exec /bin/sh -c umask]
+  # Changed on 2012-02-13: umask is deliberately ignored for -wal files.
+  #set umask [exec /bin/sh -c umask]
+  set umask 0
+  
 
   do_test wal2-12.1 {
     sqlite3 db test.db
     execsql { 
       CREATE TABLE tx(y, z);
       PRAGMA journal_mode = WAL;
     }
     db close
     list [file exists test.db-wal] [file exists test.db-shm]
   } {0 0}
@@ skipping 115 matching lines @@
       } $b($can_read,$can_write)
     }
     catch { db close }
   }
 }
 
 #-------------------------------------------------------------------------
 # Test that "PRAGMA checkpoint_fullsync" appears to be working.
 #
 foreach {tn sql reslist} {
-  1 { }                                 {8 0 3 0 5 0}
-  2 { PRAGMA checkpoint_fullfsync = 1 } {8 4 3 2 5 2}
-  3 { PRAGMA checkpoint_fullfsync = 0 } {8 0 3 0 5 0}
+  1 { }                                 {10 0 4 0 6 0}
+  2 { PRAGMA checkpoint_fullfsync = 1 } {10 4 4 2 6 2}
+  3 { PRAGMA checkpoint_fullfsync = 0 } {10 0 4 0 6 0}
 } {
   faultsim_delete_and_reopen
 
   execsql {PRAGMA auto_vacuum = 0}
   execsql $sql
+  do_execsql_test wal2-14.$tn.0 { PRAGMA page_size = 4096 }   {}
   do_execsql_test wal2-14.$tn.1 { PRAGMA journal_mode = WAL } {wal}
 
   set sqlite_sync_count 0
   set sqlite_fullsync_count 0
 
   do_execsql_test wal2-14.$tn.2 {
     PRAGMA wal_autocheckpoint = 10;
     CREATE TABLE t1(a, b);                -- 2 wal syncs
-    INSERT INTO t1 VALUES(1, 2);          -- 1 wal sync
+    INSERT INTO t1 VALUES(1, 2);          -- 2 wal sync
     PRAGMA wal_checkpoint;                -- 1 wal sync, 1 db sync
     BEGIN;
       INSERT INTO t1 VALUES(3, 4);
       INSERT INTO t1 VALUES(5, 6);
-    COMMIT;                               -- 1 wal sync
+    COMMIT;                               -- 2 wal sync
     PRAGMA wal_checkpoint;                -- 1 wal sync, 1 db sync
-  } {10 0 5 5 0 2 2}
+  } {10 0 3 3 0 1 1}
 
   do_test wal2-14.$tn.3 {
+    cond_incr_sync_count 1
     list $sqlite_sync_count $sqlite_fullsync_count
   } [lrange $reslist 0 1]
 
   set sqlite_sync_count 0
   set sqlite_fullsync_count 0
 
   do_test wal2-14.$tn.4 {
     execsql { INSERT INTO t1 VALUES(7, zeroblob(12*4096)) }
     list $sqlite_sync_count $sqlite_fullsync_count
   } [lrange $reslist 2 3]
@@ skipping 10 matching lines @@
     list $sqlite_sync_count $sqlite_fullsync_count
   } [lrange $reslist 4 5]
 }
 
 catch { db close }
 
 # PRAGMA checkpoint_fullsync
 # PRAGMA fullfsync
 # PRAGMA synchronous
 #
-foreach {tn settings commit_sync ckpt_sync} {
-  1  {0 0 off}     {0 0}  {0 0}
-  2  {0 0 normal}  {0 0}  {2 0}
-  3  {0 0 full}    {1 0}  {2 0}
+foreach {tn settings restart_sync commit_sync ckpt_sync} {
+  1  {0 0 off}     {0 0}  {0 0}  {0 0}
+  2  {0 0 normal}  {1 0}  {0 0}  {2 0}
+  3  {0 0 full}    {2 0}  {1 0}  {2 0}
 
-  4  {0 1 off}     {0 0}  {0 0}
-  5  {0 1 normal}  {0 0}  {0 2}
-  6  {0 1 full}    {0 1}  {0 2}
+  4  {0 1 off}     {0 0}  {0 0}  {0 0}
+  5  {0 1 normal}  {0 1}  {0 0}  {0 2}
+  6  {0 1 full}    {0 2}  {0 1}  {0 2}
 
-  7  {1 0 off}     {0 0}  {0 0}
-  8  {1 0 normal}  {0 0}  {0 2}
-  9  {1 0 full}    {1 0}  {0 2}
+  7  {1 0 off}     {0 0}  {0 0}  {0 0}
+  8  {1 0 normal}  {1 0}  {0 0}  {0 2}
+  9  {1 0 full}    {2 0}  {1 0}  {0 2}
 
-  10 {1 1 off}     {0 0}  {0 0}
-  11 {1 1 normal}  {0 0}  {0 2}
-  12 {1 1 full}    {0 1}  {0 2}
+  10 {1 1 off}     {0 0}  {0 0}  {0 0}
+  11 {1 1 normal}  {0 1}  {0 0}  {0 2}
+  12 {1 1 full}    {0 2}  {0 1}  {0 2}
 } {
   forcedelete test.db
 
   testvfs tvfs -default 1
   tvfs filter xSync
   tvfs script xSyncCb
   proc xSyncCb {method file fileid flags} {
     incr ::sync($flags)
   }
 
   sqlite3 db test.db
   do_execsql_test 15.$tn.1 "
+    PRAGMA page_size = 4096;
     CREATE TABLE t1(x);
+    PRAGMA wal_autocheckpoint = OFF;
     PRAGMA journal_mode = WAL;
     PRAGMA checkpoint_fullfsync = [lindex $settings 0];
     PRAGMA fullfsync = [lindex $settings 1];
     PRAGMA synchronous = [lindex $settings 2];
-  " {wal}
+  " {0 wal}
 
   do_test 15.$tn.2 {
     set sync(normal) 0
     set sync(full) 0
     execsql { INSERT INTO t1 VALUES('abc') }
     list $::sync(normal) $::sync(full)
+  } $restart_sync
+
+  do_test 15.$tn.3 {
+    set sync(normal) 0
+    set sync(full) 0
+    execsql { INSERT INTO t1 VALUES('abc') }
+    list $::sync(normal) $::sync(full)
   } $commit_sync
 
-  do_test 15.$tn.3 {
+  do_test 15.$tn.4 {
     set sync(normal) 0
     set sync(full) 0
     execsql { INSERT INTO t1 VALUES('def') }
     list $::sync(normal) $::sync(full)
   } $commit_sync
 
-  do_test 15.$tn.4 {
+  do_test 15.$tn.5 {
     set sync(normal) 0
     set sync(full) 0
     execsql { PRAGMA wal_checkpoint }
     list $::sync(normal) $::sync(full)
   } $ckpt_sync
   
   db close
   tvfs delete
 }
 
 
 
 finish_test