Import SQLite 3.8.7.4.

third_party/sqlite/src/test/walcksum.test

 # 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.
 #
 #***********************************************************************
@@ skipping 135 matching lines @@
 #     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
+    forcedelete 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
+    forcecopy test.db test2.db
+    forcecopy 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
+    forcecopy test2.db test.db
+    forcecopy 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;
@@ skipping 27 matching lines @@
   } [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
+  forcecopy test.db test2.db
+  forcecopy 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
@@ skipping 24 matching lines @@
   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
+  forcedelete 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
+  forcecopy test.db test2.db
+  forcecopy 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
+  forcedelete 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
+  forcecopy test.db-wal test2.db-wal
+  forcecopy 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
+forcecopy 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
+      forcecopy 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
-