Import SQLite 3.7.6.3.

third_party/sqlite/src/test/walcksum.test

Index: third_party/sqlite/src/test/walcksum.test
diff --git a/third_party/sqlite/src/test/walcksum.test b/third_party/sqlite/src/test/walcksum.test
new file mode 100644
index 0000000000000000000000000000000000000000..b2c4a90530159c1a2680d45f01b689e1442ee488
--- /dev/null
+++ b/third_party/sqlite/src/test/walcksum.test
@@ -0,0 +1,393 @@
+# 2010 May 24
+#
+# 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.
+#
+#***********************************************************************
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/wal_common.tcl
+
+ifcapable !wal {finish_test ; return }
+
+# Read and return the contents of file $filename. Treat the content as
+# binary data.
+#
+proc readfile {filename} {
+  set fd [open $filename]
+  fconfigure $fd -encoding binary
+  fconfigure $fd -translation binary
+  set data [read $fd]
+  close $fd
+  return $data
+}
+
+#
+# File $filename must be a WAL file on disk. Check that the checksum of frame
+# $iFrame in the file is correct when interpreting data as $endian-endian
+# integers ($endian must be either "big" or "little"). If the checksum looks
+# correct, return 1. Otherwise 0.
+#
+proc log_checksum_verify {filename iFrame endian} {
+  set data [readfile $filename]
+
+  foreach {offset c1 c2} [log_checksum_calc $data $iFrame $endian] {}
+
+  binary scan [string range $data $offset [expr $offset+7]] II expect1 expect2
+  set expect1 [expr $expect1&0xFFFFFFFF]
+  set expect2 [expr $expect2&0xFFFFFFFF]
+
+  expr {$c1==$expect1 && $c2==$expect2}
+}
+
+# File $filename must be a WAL file on disk. Compute the checksum for frame
+# $iFrame in the file by interpreting data as $endian-endian integers 
+# ($endian must be either "big" or "little"). Then write the computed 
+# checksum into the file.
+#
+proc log_checksum_write {filename iFrame endian} {
+  set data [readfile $filename]
+
+  foreach {offset c1 c2} [log_checksum_calc $data $iFrame $endian] {}
+
+  set bin [binary format II $c1 $c2]
+  set fd [open $filename r+]
+  fconfigure $fd -encoding binary
+  fconfigure $fd -translation binary
+  seek $fd $offset
+  puts -nonewline $fd $bin
+  close $fd
+}
+
+# Calculate and return the checksum for a particular frame in a WAL.
+#
+# Arguments are:
+#
+#   $data         Blob containing the entire contents of a WAL.
+#
+#   $iFrame       Frame number within the $data WAL. Frames are numbered 
+#                 starting at 1.
+#
+#   $endian       One of "big" or "little".
+#
+# Returns a list of three elements, as follows:
+#
+#   * The byte offset of the checksum belonging to frame $iFrame in the WAL.
+#   * The first integer in the calculated version of the checksum.
+#   * The second integer in the calculated version of the checksum.
+#
+proc log_checksum_calc {data iFrame endian} {
+  
+  binary scan [string range $data 8 11] I pgsz
+  if {$iFrame > 1} {
+    set n [wal_file_size [expr $iFrame-2] $pgsz]
+    binary scan [string range $data [expr $n+16] [expr $n+23]] II c1 c2
+  } else {
+    set c1 0
+    set c2 0
+    wal_cksum $endian c1 c2 [string range $data 0 23]
+  }
+
+  set n [wal_file_size [expr $iFrame-1] $pgsz]
+  wal_cksum $endian c1 c2 [string range $data $n [expr $n+7]]
+  wal_cksum $endian c1 c2 [string range $data [expr $n+24] [expr $n+24+$pgsz-1]]
+
+  list [expr $n+16] $c1 $c2
+}
+
+#
+# File $filename must be a WAL file on disk. Set the 'magic' field of the
+# WAL header to indicate that checksums are $endian-endian ($endian must be
+# either "big" or "little").
+#
+# Also update the wal header checksum (since the wal header contents may
+# have changed).
+#
+proc log_checksum_writemagic {filename endian} {
+  set val [expr {0x377f0682 | ($endian == "big" ? 1 : 0)}]
+  set bin [binary format I $val]
+  set fd [open $filename r+]
+  fconfigure $fd -encoding binary
+  fconfigure $fd -translation binary
+  puts -nonewline $fd $bin
+
+  seek $fd 0
+  set blob [read $fd 24]
+  set c1 0
+  set c2 0
+  wal_cksum $endian c1 c2 $blob 
+  seek $fd 24
+  puts -nonewline $fd [binary format II $c1 $c2]
+
+  close $fd
+}
+
+#-------------------------------------------------------------------------
+# Test cases walcksum-1.* attempt to verify the following:
+#
+#   * That both native and non-native order checksum log files can 
+#      be recovered.
+#
+#   * That when appending to native or non-native checksum log files 
+#     SQLite continues to use the right kind of checksums.
+#
+#   * Test point 2 when the appending process is not one that recovered
+#     the log file.
+#
+#   * Test that both native and non-native checksum log files can be
+#     checkpointed. And that after doing so the next write to the log
+#     file occurs using native byte-order checksums. 
+#
+set native "big"
+if {$::tcl_platform(byteOrder) == "littleEndian"} { set native "little" }
+foreach endian {big little} {
+
+  # Create a database. Leave some data in the log file.
+  #
+  do_test walcksum-1.$endian.1 {
+    catch { db close }
+    file delete -force test.db test.db-wal test.db-journal
+    sqlite3 db test.db
+    execsql {
+      PRAGMA page_size = 1024;
+      PRAGMA auto_vacuum = 0;
+      PRAGMA synchronous = NORMAL;
+
+      CREATE TABLE t1(a PRIMARY KEY, b);
+      INSERT INTO t1 VALUES(1,  'one');
+      INSERT INTO t1 VALUES(2,  'two');
+      INSERT INTO t1 VALUES(3,  'three');
+      INSERT INTO t1 VALUES(5,  'five');
+
+      PRAGMA journal_mode = WAL;
+      INSERT INTO t1 VALUES(8,  'eight');
+      INSERT INTO t1 VALUES(13, 'thirteen');
+      INSERT INTO t1 VALUES(21, 'twentyone');
+    }
+
+    file copy -force test.db test2.db
+    file copy -force test.db-wal test2.db-wal
+    db close
+
+    list [file size test2.db] [file size test2.db-wal]
+  } [list [expr 1024*3] [wal_file_size 6 1024]]
+
+  # Verify that the checksums are valid for all frames and that they
+  # are calculated by interpreting data in native byte-order.
+  #
+  for {set f 1} {$f <= 6} {incr f} {
+    do_test walcksum-1.$endian.2.$f {
+      log_checksum_verify test2.db-wal $f $native
+    } 1
+  }
+
+  # Replace all checksums in the current WAL file with $endian versions.
+  # Then check that it is still possible to recover and read the database.
+  #
+  log_checksum_writemagic test2.db-wal $endian
+  for {set f 1} {$f <= 6} {incr f} {
+    do_test walcksum-1.$endian.3.$f {
+      log_checksum_write test2.db-wal $f $endian
+      log_checksum_verify test2.db-wal $f $endian
+    } {1}
+  }
+  do_test walcksum-1.$endian.4.1 {
+    file copy -force test2.db test.db
+    file copy -force test2.db-wal test.db-wal
+    sqlite3 db test.db
+    execsql { SELECT a FROM t1 }
+  } {1 2 3 5 8 13 21}
+
+  # Following recovery, any frames written to the log should use the same 
+  # endianness as the existing frames. Check that this is the case.
+  #
+  do_test walcksum-1.$endian.5.0 {
+    execsql { 
+      PRAGMA synchronous = NORMAL;
+      INSERT INTO t1 VALUES(34, 'thirtyfour');
+    }
+    list [file size test.db] [file size test.db-wal]
+  } [list [expr 1024*3] [wal_file_size 8 1024]]
+  for {set f 1} {$f <= 8} {incr f} {
+    do_test walcksum-1.$endian.5.$f {
+      log_checksum_verify test.db-wal $f $endian
+    } {1}
+  }
+
+  # Now connect a second connection to the database. Check that this one
+  # (not the one that did recovery) also appends frames to the log using
+  # the same endianness for checksums as the existing frames.
+  #
+  do_test walcksum-1.$endian.6 {
+    sqlite3 db2 test.db
+    execsql { 
+      PRAGMA integrity_check;
+      SELECT a FROM t1;
+    } db2
+  } {ok 1 2 3 5 8 13 21 34}
+  do_test walcksum-1.$endian.7.0 {
+    execsql { 
+      PRAGMA synchronous = NORMAL;
+      INSERT INTO t1 VALUES(55, 'fiftyfive');
+    } db2
+    list [file size test.db] [file size test.db-wal]
+  } [list [expr 1024*3] [wal_file_size 10 1024]]
+  for {set f 1} {$f <= 10} {incr f} {
+    do_test walcksum-1.$endian.7.$f {
+      log_checksum_verify test.db-wal $f $endian
+    } {1}
+  }
+
+  # Now that both the recoverer and non-recoverer have added frames to the
+  # log file, check that it can still be recovered.
+  #
+  file copy -force test.db test2.db
+  file copy -force test.db-wal test2.db-wal
+  do_test walcksum-1.$endian.7.11 {
+    sqlite3 db3 test2.db
+    execsql { 
+      PRAGMA integrity_check;
+      SELECT a FROM t1;
+    } db3
+  } {ok 1 2 3 5 8 13 21 34 55}
+  db3 close
+
+  # Run a checkpoint on the database file. Then, check that any frames written
+  # to the start of the log use native byte-order checksums.
+  #
+  do_test walcksum-1.$endian.8.1 {
+    execsql {
+      PRAGMA wal_checkpoint;
+      INSERT INTO t1 VALUES(89, 'eightynine');
+    }
+    log_checksum_verify test.db-wal 1 $native
+  } {1}
+  do_test walcksum-1.$endian.8.2 {
+    log_checksum_verify test.db-wal 2 $native
+  } {1}
+  do_test walcksum-1.$endian.8.3 {
+    log_checksum_verify test.db-wal 3 $native
+  } {0}
+
+  do_test walcksum-1.$endian.9 {
+    execsql { 
+      PRAGMA integrity_check;
+      SELECT a FROM t1;
+    } db2
+  } {ok 1 2 3 5 8 13 21 34 55 89}
+
+  catch { db close }
+  catch { db2 close }
+}
+
+#-------------------------------------------------------------------------
+# Test case walcksum-2.* tests that if a statement transaction is rolled
+# back after frames are written to the WAL, and then (after writing some
+# more) the outer transaction is committed, the WAL file is still correctly
+# formatted (and can be recovered by a second process if required).
+#
+do_test walcksum-2.1 {
+  file delete -force test.db test.db-wal test.db-journal
+  sqlite3 db test.db
+  execsql {
+    PRAGMA synchronous = NORMAL;
+    PRAGMA page_size = 1024;
+    PRAGMA journal_mode = WAL;
+    PRAGMA cache_size = 10;
+    CREATE TABLE t1(x PRIMARY KEY);
+    PRAGMA wal_checkpoint;
+    INSERT INTO t1 VALUES(randomblob(800));
+    BEGIN;
+      INSERT INTO t1 SELECT randomblob(800) FROM t1;   /*   2 */
+      INSERT INTO t1 SELECT randomblob(800) FROM t1;   /*   4 */
+      INSERT INTO t1 SELECT randomblob(800) FROM t1;   /*   8 */
+      INSERT INTO t1 SELECT randomblob(800) FROM t1;   /*  16 */
+      SAVEPOINT one;
+        INSERT INTO t1 SELECT randomblob(800) FROM t1;   /*  32 */
+        INSERT INTO t1 SELECT randomblob(800) FROM t1;   /*  64 */
+        INSERT INTO t1 SELECT randomblob(800) FROM t1;   /* 128 */
+        INSERT INTO t1 SELECT randomblob(800) FROM t1;   /* 256 */
+      ROLLBACK TO one;
+      INSERT INTO t1 SELECT randomblob(800) FROM t1;   /*  32 */
+      INSERT INTO t1 SELECT randomblob(800) FROM t1;   /*  64 */
+      INSERT INTO t1 SELECT randomblob(800) FROM t1;   /* 128 */
+      INSERT INTO t1 SELECT randomblob(800) FROM t1;   /* 256 */
+    COMMIT;
+  }
+
+  file copy -force test.db test2.db
+  file copy -force test.db-wal test2.db-wal
+
+  sqlite3 db2 test2.db
+  execsql {
+    PRAGMA integrity_check;
+    SELECT count(*) FROM t1;
+  } db2
+} {ok 256}
+catch { db close }
+catch { db2 close }
+
+#-------------------------------------------------------------------------
+# Test case walcksum-3.* tests that the checksum calculation detects single 
+# byte changes to frame or frame-header data and considers the frame
+# invalid as a result.
+#
+do_test walcksum-3.1 {
+  file delete -force test.db test.db-wal test.db-journal
+  sqlite3 db test.db
+
+  execsql {
+    PRAGMA synchronous = NORMAL;
+    PRAGMA page_size = 1024;
+    CREATE TABLE t1(a, b);
+    INSERT INTO t1 VALUES(1, randomblob(300));
+    INSERT INTO t1 VALUES(2, randomblob(300));
+    PRAGMA journal_mode = WAL;
+    INSERT INTO t1 VALUES(3, randomblob(300));
+  }
+
+  file size test.db-wal
+} [wal_file_size 1 1024]
+do_test walcksum-3.2 {
+  file copy -force test.db-wal test2.db-wal
+  file copy -force test.db test2.db
+  sqlite3 db2 test2.db
+  execsql { SELECT a FROM t1 } db2
+} {1 2 3}
+db2 close
+file copy -force test.db test2.db
+
+
+foreach incr {1 2 3 20 40 60 80 100 120 140 160 180 200 220 240 253 254 255} {
+  do_test walcksum-3.3.$incr {
+    set FAIL 0
+    for {set iOff 0} {$iOff < [wal_file_size 1 1024]} {incr iOff} {
+
+      file copy -force test.db-wal test2.db-wal
+      set fd [open test2.db-wal r+]
+      fconfigure $fd -encoding binary
+      fconfigure $fd -translation binary
+  
+      seek $fd $iOff
+      binary scan [read $fd 1] c x
+      seek $fd $iOff
+      puts -nonewline $fd [binary format c [expr {($x+$incr)&0xFF}]]
+      close $fd
+    
+      sqlite3 db2 test2.db
+      if { [execsql { SELECT a FROM t1 } db2] != "1 2" } {set FAIL 1}
+      db2 close
+    }
+    set FAIL
+  } {0}
+}
+  
+finish_test
+