Annotation of embedaddon/sqlite3/test/walcksum.test, revision 1.1
1.1 ! misho 1: # 2010 May 24
! 2: #
! 3: # The author disclaims copyright to this source code. In place of
! 4: # a legal notice, here is a blessing:
! 5: #
! 6: # May you do good and not evil.
! 7: # May you find forgiveness for yourself and forgive others.
! 8: # May you share freely, never taking more than you give.
! 9: #
! 10: #***********************************************************************
! 11: #
! 12:
! 13: set testdir [file dirname $argv0]
! 14: source $testdir/tester.tcl
! 15: source $testdir/lock_common.tcl
! 16: source $testdir/wal_common.tcl
! 17:
! 18: ifcapable !wal {finish_test ; return }
! 19:
! 20: # Read and return the contents of file $filename. Treat the content as
! 21: # binary data.
! 22: #
! 23: proc readfile {filename} {
! 24: set fd [open $filename]
! 25: fconfigure $fd -encoding binary
! 26: fconfigure $fd -translation binary
! 27: set data [read $fd]
! 28: close $fd
! 29: return $data
! 30: }
! 31:
! 32: #
! 33: # File $filename must be a WAL file on disk. Check that the checksum of frame
! 34: # $iFrame in the file is correct when interpreting data as $endian-endian
! 35: # integers ($endian must be either "big" or "little"). If the checksum looks
! 36: # correct, return 1. Otherwise 0.
! 37: #
! 38: proc log_checksum_verify {filename iFrame endian} {
! 39: set data [readfile $filename]
! 40:
! 41: foreach {offset c1 c2} [log_checksum_calc $data $iFrame $endian] {}
! 42:
! 43: binary scan [string range $data $offset [expr $offset+7]] II expect1 expect2
! 44: set expect1 [expr $expect1&0xFFFFFFFF]
! 45: set expect2 [expr $expect2&0xFFFFFFFF]
! 46:
! 47: expr {$c1==$expect1 && $c2==$expect2}
! 48: }
! 49:
! 50: # File $filename must be a WAL file on disk. Compute the checksum for frame
! 51: # $iFrame in the file by interpreting data as $endian-endian integers
! 52: # ($endian must be either "big" or "little"). Then write the computed
! 53: # checksum into the file.
! 54: #
! 55: proc log_checksum_write {filename iFrame endian} {
! 56: set data [readfile $filename]
! 57:
! 58: foreach {offset c1 c2} [log_checksum_calc $data $iFrame $endian] {}
! 59:
! 60: set bin [binary format II $c1 $c2]
! 61: set fd [open $filename r+]
! 62: fconfigure $fd -encoding binary
! 63: fconfigure $fd -translation binary
! 64: seek $fd $offset
! 65: puts -nonewline $fd $bin
! 66: close $fd
! 67: }
! 68:
! 69: # Calculate and return the checksum for a particular frame in a WAL.
! 70: #
! 71: # Arguments are:
! 72: #
! 73: # $data Blob containing the entire contents of a WAL.
! 74: #
! 75: # $iFrame Frame number within the $data WAL. Frames are numbered
! 76: # starting at 1.
! 77: #
! 78: # $endian One of "big" or "little".
! 79: #
! 80: # Returns a list of three elements, as follows:
! 81: #
! 82: # * The byte offset of the checksum belonging to frame $iFrame in the WAL.
! 83: # * The first integer in the calculated version of the checksum.
! 84: # * The second integer in the calculated version of the checksum.
! 85: #
! 86: proc log_checksum_calc {data iFrame endian} {
! 87:
! 88: binary scan [string range $data 8 11] I pgsz
! 89: if {$iFrame > 1} {
! 90: set n [wal_file_size [expr $iFrame-2] $pgsz]
! 91: binary scan [string range $data [expr $n+16] [expr $n+23]] II c1 c2
! 92: } else {
! 93: set c1 0
! 94: set c2 0
! 95: wal_cksum $endian c1 c2 [string range $data 0 23]
! 96: }
! 97:
! 98: set n [wal_file_size [expr $iFrame-1] $pgsz]
! 99: wal_cksum $endian c1 c2 [string range $data $n [expr $n+7]]
! 100: wal_cksum $endian c1 c2 [string range $data [expr $n+24] [expr $n+24+$pgsz-1]]
! 101:
! 102: list [expr $n+16] $c1 $c2
! 103: }
! 104:
! 105: #
! 106: # File $filename must be a WAL file on disk. Set the 'magic' field of the
! 107: # WAL header to indicate that checksums are $endian-endian ($endian must be
! 108: # either "big" or "little").
! 109: #
! 110: # Also update the wal header checksum (since the wal header contents may
! 111: # have changed).
! 112: #
! 113: proc log_checksum_writemagic {filename endian} {
! 114: set val [expr {0x377f0682 | ($endian == "big" ? 1 : 0)}]
! 115: set bin [binary format I $val]
! 116: set fd [open $filename r+]
! 117: fconfigure $fd -encoding binary
! 118: fconfigure $fd -translation binary
! 119: puts -nonewline $fd $bin
! 120:
! 121: seek $fd 0
! 122: set blob [read $fd 24]
! 123: set c1 0
! 124: set c2 0
! 125: wal_cksum $endian c1 c2 $blob
! 126: seek $fd 24
! 127: puts -nonewline $fd [binary format II $c1 $c2]
! 128:
! 129: close $fd
! 130: }
! 131:
! 132: #-------------------------------------------------------------------------
! 133: # Test cases walcksum-1.* attempt to verify the following:
! 134: #
! 135: # * That both native and non-native order checksum log files can
! 136: # be recovered.
! 137: #
! 138: # * That when appending to native or non-native checksum log files
! 139: # SQLite continues to use the right kind of checksums.
! 140: #
! 141: # * Test point 2 when the appending process is not one that recovered
! 142: # the log file.
! 143: #
! 144: # * Test that both native and non-native checksum log files can be
! 145: # checkpointed. And that after doing so the next write to the log
! 146: # file occurs using native byte-order checksums.
! 147: #
! 148: set native "big"
! 149: if {$::tcl_platform(byteOrder) == "littleEndian"} { set native "little" }
! 150: foreach endian {big little} {
! 151:
! 152: # Create a database. Leave some data in the log file.
! 153: #
! 154: do_test walcksum-1.$endian.1 {
! 155: catch { db close }
! 156: forcedelete test.db test.db-wal test.db-journal
! 157: sqlite3 db test.db
! 158: execsql {
! 159: PRAGMA page_size = 1024;
! 160: PRAGMA auto_vacuum = 0;
! 161: PRAGMA synchronous = NORMAL;
! 162:
! 163: CREATE TABLE t1(a PRIMARY KEY, b);
! 164: INSERT INTO t1 VALUES(1, 'one');
! 165: INSERT INTO t1 VALUES(2, 'two');
! 166: INSERT INTO t1 VALUES(3, 'three');
! 167: INSERT INTO t1 VALUES(5, 'five');
! 168:
! 169: PRAGMA journal_mode = WAL;
! 170: INSERT INTO t1 VALUES(8, 'eight');
! 171: INSERT INTO t1 VALUES(13, 'thirteen');
! 172: INSERT INTO t1 VALUES(21, 'twentyone');
! 173: }
! 174:
! 175: forcecopy test.db test2.db
! 176: forcecopy test.db-wal test2.db-wal
! 177: db close
! 178:
! 179: list [file size test2.db] [file size test2.db-wal]
! 180: } [list [expr 1024*3] [wal_file_size 6 1024]]
! 181:
! 182: # Verify that the checksums are valid for all frames and that they
! 183: # are calculated by interpreting data in native byte-order.
! 184: #
! 185: for {set f 1} {$f <= 6} {incr f} {
! 186: do_test walcksum-1.$endian.2.$f {
! 187: log_checksum_verify test2.db-wal $f $native
! 188: } 1
! 189: }
! 190:
! 191: # Replace all checksums in the current WAL file with $endian versions.
! 192: # Then check that it is still possible to recover and read the database.
! 193: #
! 194: log_checksum_writemagic test2.db-wal $endian
! 195: for {set f 1} {$f <= 6} {incr f} {
! 196: do_test walcksum-1.$endian.3.$f {
! 197: log_checksum_write test2.db-wal $f $endian
! 198: log_checksum_verify test2.db-wal $f $endian
! 199: } {1}
! 200: }
! 201: do_test walcksum-1.$endian.4.1 {
! 202: forcecopy test2.db test.db
! 203: forcecopy test2.db-wal test.db-wal
! 204: sqlite3 db test.db
! 205: execsql { SELECT a FROM t1 }
! 206: } {1 2 3 5 8 13 21}
! 207:
! 208: # Following recovery, any frames written to the log should use the same
! 209: # endianness as the existing frames. Check that this is the case.
! 210: #
! 211: do_test walcksum-1.$endian.5.0 {
! 212: execsql {
! 213: PRAGMA synchronous = NORMAL;
! 214: INSERT INTO t1 VALUES(34, 'thirtyfour');
! 215: }
! 216: list [file size test.db] [file size test.db-wal]
! 217: } [list [expr 1024*3] [wal_file_size 8 1024]]
! 218: for {set f 1} {$f <= 8} {incr f} {
! 219: do_test walcksum-1.$endian.5.$f {
! 220: log_checksum_verify test.db-wal $f $endian
! 221: } {1}
! 222: }
! 223:
! 224: # Now connect a second connection to the database. Check that this one
! 225: # (not the one that did recovery) also appends frames to the log using
! 226: # the same endianness for checksums as the existing frames.
! 227: #
! 228: do_test walcksum-1.$endian.6 {
! 229: sqlite3 db2 test.db
! 230: execsql {
! 231: PRAGMA integrity_check;
! 232: SELECT a FROM t1;
! 233: } db2
! 234: } {ok 1 2 3 5 8 13 21 34}
! 235: do_test walcksum-1.$endian.7.0 {
! 236: execsql {
! 237: PRAGMA synchronous = NORMAL;
! 238: INSERT INTO t1 VALUES(55, 'fiftyfive');
! 239: } db2
! 240: list [file size test.db] [file size test.db-wal]
! 241: } [list [expr 1024*3] [wal_file_size 10 1024]]
! 242: for {set f 1} {$f <= 10} {incr f} {
! 243: do_test walcksum-1.$endian.7.$f {
! 244: log_checksum_verify test.db-wal $f $endian
! 245: } {1}
! 246: }
! 247:
! 248: # Now that both the recoverer and non-recoverer have added frames to the
! 249: # log file, check that it can still be recovered.
! 250: #
! 251: forcecopy test.db test2.db
! 252: forcecopy test.db-wal test2.db-wal
! 253: do_test walcksum-1.$endian.7.11 {
! 254: sqlite3 db3 test2.db
! 255: execsql {
! 256: PRAGMA integrity_check;
! 257: SELECT a FROM t1;
! 258: } db3
! 259: } {ok 1 2 3 5 8 13 21 34 55}
! 260: db3 close
! 261:
! 262: # Run a checkpoint on the database file. Then, check that any frames written
! 263: # to the start of the log use native byte-order checksums.
! 264: #
! 265: do_test walcksum-1.$endian.8.1 {
! 266: execsql {
! 267: PRAGMA wal_checkpoint;
! 268: INSERT INTO t1 VALUES(89, 'eightynine');
! 269: }
! 270: log_checksum_verify test.db-wal 1 $native
! 271: } {1}
! 272: do_test walcksum-1.$endian.8.2 {
! 273: log_checksum_verify test.db-wal 2 $native
! 274: } {1}
! 275: do_test walcksum-1.$endian.8.3 {
! 276: log_checksum_verify test.db-wal 3 $native
! 277: } {0}
! 278:
! 279: do_test walcksum-1.$endian.9 {
! 280: execsql {
! 281: PRAGMA integrity_check;
! 282: SELECT a FROM t1;
! 283: } db2
! 284: } {ok 1 2 3 5 8 13 21 34 55 89}
! 285:
! 286: catch { db close }
! 287: catch { db2 close }
! 288: }
! 289:
! 290: #-------------------------------------------------------------------------
! 291: # Test case walcksum-2.* tests that if a statement transaction is rolled
! 292: # back after frames are written to the WAL, and then (after writing some
! 293: # more) the outer transaction is committed, the WAL file is still correctly
! 294: # formatted (and can be recovered by a second process if required).
! 295: #
! 296: do_test walcksum-2.1 {
! 297: forcedelete test.db test.db-wal test.db-journal
! 298: sqlite3 db test.db
! 299: execsql {
! 300: PRAGMA synchronous = NORMAL;
! 301: PRAGMA page_size = 1024;
! 302: PRAGMA journal_mode = WAL;
! 303: PRAGMA cache_size = 10;
! 304: CREATE TABLE t1(x PRIMARY KEY);
! 305: PRAGMA wal_checkpoint;
! 306: INSERT INTO t1 VALUES(randomblob(800));
! 307: BEGIN;
! 308: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 2 */
! 309: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 4 */
! 310: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 8 */
! 311: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 16 */
! 312: SAVEPOINT one;
! 313: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 32 */
! 314: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 64 */
! 315: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 128 */
! 316: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 256 */
! 317: ROLLBACK TO one;
! 318: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 32 */
! 319: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 64 */
! 320: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 128 */
! 321: INSERT INTO t1 SELECT randomblob(800) FROM t1; /* 256 */
! 322: COMMIT;
! 323: }
! 324:
! 325: forcecopy test.db test2.db
! 326: forcecopy test.db-wal test2.db-wal
! 327:
! 328: sqlite3 db2 test2.db
! 329: execsql {
! 330: PRAGMA integrity_check;
! 331: SELECT count(*) FROM t1;
! 332: } db2
! 333: } {ok 256}
! 334: catch { db close }
! 335: catch { db2 close }
! 336:
! 337: #-------------------------------------------------------------------------
! 338: # Test case walcksum-3.* tests that the checksum calculation detects single
! 339: # byte changes to frame or frame-header data and considers the frame
! 340: # invalid as a result.
! 341: #
! 342: do_test walcksum-3.1 {
! 343: forcedelete test.db test.db-wal test.db-journal
! 344: sqlite3 db test.db
! 345:
! 346: execsql {
! 347: PRAGMA synchronous = NORMAL;
! 348: PRAGMA page_size = 1024;
! 349: CREATE TABLE t1(a, b);
! 350: INSERT INTO t1 VALUES(1, randomblob(300));
! 351: INSERT INTO t1 VALUES(2, randomblob(300));
! 352: PRAGMA journal_mode = WAL;
! 353: INSERT INTO t1 VALUES(3, randomblob(300));
! 354: }
! 355:
! 356: file size test.db-wal
! 357: } [wal_file_size 1 1024]
! 358: do_test walcksum-3.2 {
! 359: forcecopy test.db-wal test2.db-wal
! 360: forcecopy test.db test2.db
! 361: sqlite3 db2 test2.db
! 362: execsql { SELECT a FROM t1 } db2
! 363: } {1 2 3}
! 364: db2 close
! 365: forcecopy test.db test2.db
! 366:
! 367:
! 368: foreach incr {1 2 3 20 40 60 80 100 120 140 160 180 200 220 240 253 254 255} {
! 369: do_test walcksum-3.3.$incr {
! 370: set FAIL 0
! 371: for {set iOff 0} {$iOff < [wal_file_size 1 1024]} {incr iOff} {
! 372:
! 373: forcecopy test.db-wal test2.db-wal
! 374: set fd [open test2.db-wal r+]
! 375: fconfigure $fd -encoding binary
! 376: fconfigure $fd -translation binary
! 377:
! 378: seek $fd $iOff
! 379: binary scan [read $fd 1] c x
! 380: seek $fd $iOff
! 381: puts -nonewline $fd [binary format c [expr {($x+$incr)&0xFF}]]
! 382: close $fd
! 383:
! 384: sqlite3 db2 test2.db
! 385: if { [execsql { SELECT a FROM t1 } db2] != "1 2" } {set FAIL 1}
! 386: db2 close
! 387: }
! 388: set FAIL
! 389: } {0}
! 390: }
! 391:
! 392: finish_test
! 393:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to walcksum.test CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test