Annotation of embedaddon/sqlite3/test/walfault.test, revision 1.1
1.1 ! misho 1: # 2010 May 03
! 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: # This file implements regression tests for SQLite library. The
! 12: # focus of this file is testing the operation of the library in
! 13: # "PRAGMA journal_mode=WAL" mode.
! 14: #
! 15:
! 16: set testdir [file dirname $argv0]
! 17: source $testdir/tester.tcl
! 18: source $testdir/malloc_common.tcl
! 19: source $testdir/lock_common.tcl
! 20:
! 21: ifcapable !wal {finish_test ; return }
! 22:
! 23: #-------------------------------------------------------------------------
! 24: # This test case, walfault-1-*, simulates faults while executing a
! 25: #
! 26: # PRAGMA journal_mode = WAL;
! 27: #
! 28: # statement immediately after creating a new database.
! 29: #
! 30: do_test walfault-1-pre-1 {
! 31: faultsim_delete_and_reopen
! 32: faultsim_save_and_close
! 33: } {}
! 34: do_faultsim_test walfault-1 -prep {
! 35: faultsim_restore_and_reopen
! 36: } -body {
! 37: db eval { PRAGMA main.journal_mode = WAL }
! 38: } -test {
! 39:
! 40: faultsim_test_result {0 wal}
! 41:
! 42: # Test that the connection that encountered an error as part of
! 43: # "PRAGMA journal_mode = WAL" and a new connection use the same
! 44: # journal mode when accessing the database.
! 45: #
! 46: # If "PRAGMA journal_mode" is executed immediately, connection [db] (the
! 47: # one that hit the error in journal_mode="WAL") might return "wal" even
! 48: # if it failed to switch the database to WAL mode. This is not considered
! 49: # a problem. When it tries to read the database, connection [db] correctly
! 50: # recognizes that it is a rollback database and switches back to a
! 51: # rollback compatible journal mode.
! 52: #
! 53: if {[permutation] != "inmemory_journal"} {
! 54: set jm [db one {SELECT * FROM sqlite_master ; PRAGMA main.journal_mode}]
! 55: sqlite3 db2 test.db
! 56: set jm2 [db2 one {SELECT * FROM sqlite_master ; PRAGMA main.journal_mode}]
! 57: db2 close
! 58:
! 59: if { $jm!=$jm2 } { error "Journal modes do not match: $jm $jm2" }
! 60: if { $testrc==0 && $jm!="wal" } { error "Journal mode is not WAL" }
! 61: }
! 62: }
! 63:
! 64: #--------------------------------------------------------------------------
! 65: # Test case walfault-2-* tests fault injection during recovery of a
! 66: # short WAL file (a dozen frames or thereabouts).
! 67: #
! 68: do_test walfault-2-pre-1 {
! 69: sqlite3 db test.db
! 70: execsql {
! 71: PRAGMA journal_mode = WAL;
! 72: BEGIN;
! 73: CREATE TABLE x(y, z, UNIQUE(y, z));
! 74: INSERT INTO x VALUES(randomblob(100), randomblob(100));
! 75: COMMIT;
! 76: PRAGMA wal_checkpoint;
! 77:
! 78: INSERT INTO x SELECT randomblob(100), randomblob(100) FROM x;
! 79: INSERT INTO x SELECT randomblob(100), randomblob(100) FROM x;
! 80: INSERT INTO x SELECT randomblob(100), randomblob(100) FROM x;
! 81: }
! 82: execsql {
! 83: SELECT count(*) FROM x
! 84: }
! 85: } {8}
! 86: do_test walfault-2-pre-2 {
! 87: faultsim_save_and_close
! 88: faultsim_restore_and_reopen
! 89: execsql { SELECT count(*) FROM x }
! 90: } {8}
! 91: do_faultsim_test walfault-2 -prep {
! 92: faultsim_restore_and_reopen
! 93: } -body {
! 94: execsql { SELECT count(*) FROM x }
! 95: } -test {
! 96: faultsim_test_result {0 8}
! 97: faultsim_integrity_check
! 98: }
! 99:
! 100: #--------------------------------------------------------------------------
! 101: # Test fault injection while writing and checkpointing a small WAL file.
! 102: #
! 103: do_test walfault-3-pre-1 {
! 104: sqlite3 db test.db
! 105: execsql {
! 106: PRAGMA auto_vacuum = 1;
! 107: PRAGMA journal_mode = WAL;
! 108: CREATE TABLE abc(a PRIMARY KEY);
! 109: INSERT INTO abc VALUES(randomblob(1500));
! 110: }
! 111: db close
! 112: faultsim_save_and_close
! 113: } {}
! 114: do_faultsim_test walfault-3 -prep {
! 115: faultsim_restore_and_reopen
! 116: } -body {
! 117: db eval {
! 118: DELETE FROM abc;
! 119: PRAGMA wal_checkpoint;
! 120: }
! 121: set {} {}
! 122: } -test {
! 123: faultsim_test_result {0 {}}
! 124: }
! 125:
! 126: #--------------------------------------------------------------------------
! 127: #
! 128: if {[permutation] != "inmemory_journal"} {
! 129: faultsim_delete_and_reopen
! 130: faultsim_save_and_close
! 131: do_faultsim_test walfault-4 -prep {
! 132: faultsim_restore_and_reopen
! 133: } -body {
! 134: execsql {
! 135: PRAGMA auto_vacuum = 0;
! 136: PRAGMA journal_mode = WAL;
! 137: CREATE TABLE t1(a PRIMARY KEY, b);
! 138: INSERT INTO t1 VALUES('a', 'b');
! 139: PRAGMA wal_checkpoint;
! 140: SELECT * FROM t1;
! 141: }
! 142: } -test {
! 143: # Update: The following changed from {0 {wal 0 7 7 a b}} as a result
! 144: # of PSOW being set by default.
! 145: faultsim_test_result {0 {wal 0 5 5 a b}}
! 146: faultsim_integrity_check
! 147: }
! 148: }
! 149:
! 150: #--------------------------------------------------------------------------
! 151: #
! 152: do_test walfault-5-pre-1 {
! 153: faultsim_delete_and_reopen
! 154: execsql {
! 155: PRAGMA page_size = 512;
! 156: PRAGMA journal_mode = WAL;
! 157: }
! 158: faultsim_save_and_close
! 159: } {}
! 160: do_faultsim_test walfault-5 -faults shmerr* -prep {
! 161: faultsim_restore_and_reopen
! 162: execsql { PRAGMA wal_autocheckpoint = 0 }
! 163: shmfault filter xShmMap
! 164: } -body {
! 165: execsql {
! 166: CREATE TABLE t1(x);
! 167: BEGIN;
! 168: INSERT INTO t1 VALUES(randomblob(400)); /* 1 */
! 169: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 2 */
! 170: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 4 */
! 171: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 8 */
! 172: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 16 */
! 173: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 32 */
! 174: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 64 */
! 175: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 128 */
! 176: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 256 */
! 177: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 512 */
! 178: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 1024 */
! 179: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 2048 */
! 180: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 4096 */
! 181: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 8192 */
! 182: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 16384 */
! 183: COMMIT;
! 184: SELECT count(*) FROM t1;
! 185: }
! 186: } -test {
! 187: faultsim_test_result {0 16384}
! 188: faultsim_integrity_check
! 189: }
! 190:
! 191: #--------------------------------------------------------------------------
! 192: #
! 193: do_test walfault-6-pre-1 {
! 194: faultsim_delete_and_reopen
! 195: execsql {
! 196: PRAGMA page_size = 512;
! 197: PRAGMA journal_mode = WAL;
! 198: PRAGMA wal_autocheckpoint = 0;
! 199: CREATE TABLE t1(x);
! 200: BEGIN;
! 201: INSERT INTO t1 VALUES(randomblob(400)); /* 1 */
! 202: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 2 */
! 203: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 4 */
! 204: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 8 */
! 205: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 16 */
! 206: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 32 */
! 207: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 64 */
! 208: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 128 */
! 209: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 256 */
! 210: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 512 */
! 211: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 1024 */
! 212: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 2048 */
! 213: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 4096 */
! 214: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 8192 */
! 215: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 16384 */
! 216: COMMIT;
! 217: }
! 218: faultsim_save_and_close
! 219: } {}
! 220: do_faultsim_test walfault-6 -faults shmerr* -prep {
! 221: faultsim_restore_and_reopen
! 222: shmfault filter xShmMap
! 223: } -body {
! 224: execsql { SELECT count(*) FROM t1 }
! 225: } -test {
! 226: faultsim_test_result {0 16384}
! 227: faultsim_integrity_check
! 228: set n [db one {SELECT count(*) FROM t1}]
! 229: if {$n != 16384 && $n != 0} { error "Incorrect number of rows: $n" }
! 230: }
! 231:
! 232: #--------------------------------------------------------------------------
! 233: #
! 234: do_test walfault-7-pre-1 {
! 235: faultsim_delete_and_reopen
! 236: execsql {
! 237: PRAGMA page_size = 512;
! 238: PRAGMA journal_mode = WAL;
! 239: PRAGMA wal_autocheckpoint = 0;
! 240: CREATE TABLE t1(x);
! 241: BEGIN;
! 242: INSERT INTO t1 VALUES(randomblob(400)); /* 1 */
! 243: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 2 */
! 244: INSERT INTO t1 SELECT randomblob(400) FROM t1; /* 4 */
! 245: COMMIT;
! 246: }
! 247: faultsim_save_and_close
! 248: } {}
! 249: do_faultsim_test walfault-7 -prep {
! 250: faultsim_restore_and_reopen
! 251: } -body {
! 252: execsql { SELECT count(*) FROM t1 }
! 253: } -test {
! 254: faultsim_test_result {0 4}
! 255: set n [db one {SELECT count(*) FROM t1}]
! 256: if {$n != 4 && $n != 0} { error "Incorrect number of rows: $n" }
! 257: }
! 258:
! 259: #--------------------------------------------------------------------------
! 260: #
! 261: do_test walfault-8-pre-1 {
! 262: faultsim_delete_and_reopen
! 263: execsql {
! 264: PRAGMA journal_mode = WAL;
! 265: CREATE TABLE abc(a PRIMARY KEY);
! 266: INSERT INTO abc VALUES(randomblob(900));
! 267: }
! 268: faultsim_save_and_close
! 269: } {}
! 270: do_faultsim_test walfault-8 -prep {
! 271: faultsim_restore_and_reopen
! 272: execsql { PRAGMA cache_size = 10 }
! 273: } -body {
! 274: execsql {
! 275: BEGIN;
! 276: INSERT INTO abc SELECT randomblob(900) FROM abc; /* 1 */
! 277: --INSERT INTO abc SELECT randomblob(900) FROM abc; /* 2 */
! 278: --INSERT INTO abc SELECT randomblob(900) FROM abc; /* 4 */
! 279: --INSERT INTO abc SELECT randomblob(900) FROM abc; /* 8 */
! 280: ROLLBACK;
! 281: SELECT count(*) FROM abc;
! 282: }
! 283: } -test {
! 284: faultsim_test_result {0 1}
! 285:
! 286: faultsim_integrity_check
! 287: catch { db eval ROLLBACK }
! 288: faultsim_integrity_check
! 289:
! 290: set n [db one {SELECT count(*) FROM abc}]
! 291: if {$n != 1} { error "Incorrect number of rows: $n" }
! 292: }
! 293:
! 294: #--------------------------------------------------------------------------
! 295: #
! 296: do_test walfault-9-pre-1 {
! 297: faultsim_delete_and_reopen
! 298: execsql {
! 299: PRAGMA journal_mode = WAL;
! 300: CREATE TABLE abc(a PRIMARY KEY);
! 301: INSERT INTO abc VALUES(randomblob(900));
! 302: }
! 303: faultsim_save_and_close
! 304: } {}
! 305: do_faultsim_test walfault-9 -prep {
! 306: #if {$iFail<73} { set iFail 73 }
! 307: #if {$iFail>73} { exit }
! 308:
! 309: faultsim_restore_and_reopen
! 310: execsql { PRAGMA cache_size = 10 }
! 311: } -body {
! 312: execsql {
! 313: BEGIN;
! 314: INSERT INTO abc SELECT randomblob(900) FROM abc; /* 1 */
! 315: SAVEPOINT spoint;
! 316: INSERT INTO abc SELECT randomblob(900) FROM abc; /* 2 */
! 317: INSERT INTO abc SELECT randomblob(900) FROM abc; /* 4 */
! 318: INSERT INTO abc SELECT randomblob(900) FROM abc; /* 8 */
! 319: ROLLBACK TO spoint;
! 320: COMMIT;
! 321: SELECT count(*) FROM abc;
! 322: }
! 323: } -test {
! 324: faultsim_test_result {0 2}
! 325: faultsim_integrity_check
! 326:
! 327: catch { db eval { ROLLBACK TO spoint } }
! 328: catch { db eval { COMMIT } }
! 329: set n [db one {SELECT count(*) FROM abc}]
! 330: if {$n != 1 && $n != 2} { error "Incorrect number of rows: $n" }
! 331: }
! 332:
! 333: do_test walfault-10-pre1 {
! 334: faultsim_delete_and_reopen
! 335: execsql {
! 336: PRAGMA journal_mode = WAL;
! 337: PRAGMA wal_autocheckpoint = 0;
! 338: CREATE TABLE z(zz INTEGER PRIMARY KEY, zzz BLOB);
! 339: CREATE INDEX zzzz ON z(zzz);
! 340: INSERT INTO z VALUES(NULL, randomblob(800));
! 341: INSERT INTO z VALUES(NULL, randomblob(800));
! 342: INSERT INTO z SELECT NULL, randomblob(800) FROM z;
! 343: INSERT INTO z SELECT NULL, randomblob(800) FROM z;
! 344: INSERT INTO z SELECT NULL, randomblob(800) FROM z;
! 345: INSERT INTO z SELECT NULL, randomblob(800) FROM z;
! 346: INSERT INTO z SELECT NULL, randomblob(800) FROM z;
! 347: }
! 348: faultsim_save_and_close
! 349: } {}
! 350: do_faultsim_test walfault-10 -prep {
! 351: faultsim_restore_and_reopen
! 352: execsql {
! 353: PRAGMA cache_size = 10;
! 354: BEGIN;
! 355: UPDATE z SET zzz = randomblob(799);
! 356: }
! 357:
! 358: set ::stmt [sqlite3_prepare db "SELECT zzz FROM z WHERE zz IN (1, 2, 3)" -1]
! 359: sqlite3_step $::stmt
! 360: } -body {
! 361: execsql { INSERT INTO z VALUES(NULL, NULL) }
! 362: } -test {
! 363: sqlite3_finalize $::stmt
! 364: faultsim_integrity_check
! 365:
! 366: faultsim_test_result {0 {}}
! 367: catch { db eval { ROLLBACK } }
! 368: faultsim_integrity_check
! 369:
! 370: set n [db eval {SELECT count(*), sum(length(zzz)) FROM z}]
! 371: if {$n != "64 51200"} { error "Incorrect data: $n" }
! 372: }
! 373:
! 374: #--------------------------------------------------------------------------
! 375: # Test fault injection while checkpointing a large WAL file, if the
! 376: # checkpoint is the first operation run after opening the database.
! 377: # This means that some of the required wal-index pages are mapped as part of
! 378: # the checkpoint process, which means there are a few more opportunities
! 379: # for IO errors.
! 380: #
! 381: # To speed this up, IO errors are only simulated within xShmMap() calls.
! 382: #
! 383: do_test walfault-11-pre-1 {
! 384: sqlite3 db test.db
! 385: execsql {
! 386: PRAGMA journal_mode = WAL;
! 387: PRAGMA wal_autocheckpoint = 0;
! 388: BEGIN;
! 389: CREATE TABLE abc(a PRIMARY KEY);
! 390: INSERT INTO abc VALUES(randomblob(1500));
! 391: INSERT INTO abc VALUES(randomblob(1500));
! 392: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 4
! 393: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 8
! 394: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 16
! 395: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 32
! 396: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 64
! 397: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 128
! 398: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 256
! 399: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 512
! 400: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 1024
! 401: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 2048
! 402: INSERT INTO abc SELECT randomblob(1500) FROM abc; -- 4096
! 403: COMMIT;
! 404: }
! 405: faultsim_save_and_close
! 406: } {}
! 407: do_faultsim_test walfault-11 -faults shmerr* -prep {
! 408: catch { db2 close }
! 409: faultsim_restore_and_reopen
! 410: shmfault filter xShmMap
! 411: } -body {
! 412: db eval { SELECT count(*) FROM abc }
! 413: sqlite3 db2 test.db -vfs shmfault
! 414: db2 eval { PRAGMA wal_checkpoint }
! 415: set {} {}
! 416: } -test {
! 417: faultsim_test_result {0 {}}
! 418: }
! 419:
! 420: #-------------------------------------------------------------------------
! 421: # Test the handling of the various IO/OOM/SHM errors that may occur during
! 422: # a log recovery operation undertaken as part of a call to
! 423: # sqlite3_wal_checkpoint().
! 424: #
! 425: do_test walfault-12-pre-1 {
! 426: faultsim_delete_and_reopen
! 427: execsql {
! 428: PRAGMA journal_mode = WAL;
! 429: PRAGMA wal_autocheckpoint = 0;
! 430: BEGIN;
! 431: CREATE TABLE abc(a PRIMARY KEY);
! 432: INSERT INTO abc VALUES(randomblob(1500));
! 433: INSERT INTO abc VALUES(randomblob(1500));
! 434: COMMIT;
! 435: }
! 436: faultsim_save_and_close
! 437: } {}
! 438: do_faultsim_test walfault-12 -prep {
! 439: if {[info commands shmfault] == ""} {
! 440: testvfs shmfault -default true
! 441: }
! 442: faultsim_restore_and_reopen
! 443: db eval { SELECT * FROM sqlite_master }
! 444: shmfault shm test.db [string repeat "\000" 40]
! 445: } -body {
! 446: set rc [sqlite3_wal_checkpoint db]
! 447: if {$rc != "SQLITE_OK"} { error [sqlite3_errmsg db] }
! 448: } -test {
! 449: db close
! 450: faultsim_test_result {0 {}}
! 451: }
! 452:
! 453: #-------------------------------------------------------------------------
! 454: # Test simple recovery, reading and writing a database file using a
! 455: # heap-memory wal-index.
! 456: #
! 457: do_test walfault-13-pre-1 {
! 458: faultsim_delete_and_reopen
! 459: execsql {
! 460: PRAGMA journal_mode = WAL;
! 461: PRAGMA wal_autocheckpoint = 0;
! 462: BEGIN;
! 463: CREATE TABLE abc(a PRIMARY KEY);
! 464: INSERT INTO abc VALUES(randomblob(1500));
! 465: INSERT INTO abc VALUES(randomblob(1500));
! 466: COMMIT;
! 467: }
! 468: faultsim_save_and_close
! 469: delete_file sv_test.db-shm
! 470: } {}
! 471:
! 472: do_faultsim_test walfault-13.1 -prep {
! 473: faultsim_restore_and_reopen
! 474: } -body {
! 475: db eval { PRAGMA locking_mode = exclusive }
! 476: db eval { SELECT count(*) FROM abc }
! 477: } -test {
! 478: faultsim_test_result {0 2}
! 479: if {[file exists test.db-shm]} { error "Not using heap-memory mode" }
! 480: faultsim_integrity_check
! 481: }
! 482:
! 483: do_faultsim_test walfault-13.2 -prep {
! 484: faultsim_restore_and_reopen
! 485: db eval { PRAGMA locking_mode = exclusive }
! 486: } -body {
! 487: db eval { PRAGMA journal_mode = delete }
! 488: } -test {
! 489: faultsim_test_result {0 delete}
! 490: if {[file exists test.db-shm]} { error "Not using heap-memory mode" }
! 491: faultsim_integrity_check
! 492: }
! 493:
! 494: do_test walfault-13-pre-2 {
! 495: faultsim_delete_and_reopen
! 496: execsql {
! 497: BEGIN;
! 498: CREATE TABLE abc(a PRIMARY KEY);
! 499: INSERT INTO abc VALUES(randomblob(1500));
! 500: INSERT INTO abc VALUES(randomblob(1500));
! 501: COMMIT;
! 502: }
! 503: faultsim_save_and_close
! 504: } {}
! 505:
! 506: do_faultsim_test walfault-13.3 -prep {
! 507: faultsim_restore_and_reopen
! 508: } -body {
! 509: db eval {
! 510: PRAGMA locking_mode = exclusive;
! 511: PRAGMA journal_mode = WAL;
! 512: INSERT INTO abc VALUES(randomblob(1500));
! 513: }
! 514: } -test {
! 515: faultsim_test_result {0 {exclusive wal}}
! 516: if {[file exists test.db-shm]} { error "Not using heap-memory mode" }
! 517: faultsim_integrity_check
! 518: set nRow [db eval {SELECT count(*) FROM abc}]
! 519: if {!(($nRow==2 && $testrc) || $nRow==3)} { error "Bad db content" }
! 520: }
! 521:
! 522: #-------------------------------------------------------------------------
! 523: # Test fault-handling when wrapping around to the start of a WAL file.
! 524: #
! 525: do_test walfault-14-pre {
! 526: faultsim_delete_and_reopen
! 527: execsql {
! 528: PRAGMA auto_vacuum = 0;
! 529: PRAGMA journal_mode = WAL;
! 530: BEGIN;
! 531: CREATE TABLE abc(a PRIMARY KEY);
! 532: INSERT INTO abc VALUES(randomblob(1500));
! 533: INSERT INTO abc VALUES(randomblob(1500));
! 534: COMMIT;
! 535: }
! 536: faultsim_save_and_close
! 537: } {}
! 538: do_faultsim_test walfault-14 -prep {
! 539: faultsim_restore_and_reopen
! 540: } -body {
! 541: db eval {
! 542: PRAGMA wal_checkpoint = full;
! 543: INSERT INTO abc VALUES(randomblob(1500));
! 544: }
! 545: } -test {
! 546: faultsim_test_result {0 {0 9 9}}
! 547: faultsim_integrity_check
! 548: set nRow [db eval {SELECT count(*) FROM abc}]
! 549: if {!(($nRow==2 && $testrc) || $nRow==3)} { error "Bad db content" }
! 550: }
! 551: finish_test
! 552:
! 553: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to walfault.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