Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Add tests to pager1.test and pagerfault.test. |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | experimental |
Files: | files | file ages | folders |
SHA1: |
f5df83fd875073eee8e2269e87e2a8c9 |
User & Date: | dan 2010-06-19 17:26:37.000 |
Context
2010-06-19
| ||
18:12 | Change the name of IOCAP_SAFE_DELETE to IOCAP_UNDELETABLE_WHEN_OPEN. Have the xDeviceCharacteristics() method of the win32 VFS return this flag. (check-in: 5a5ff4e3e4 user: dan tags: experimental) | |
17:26 | Add tests to pager1.test and pagerfault.test. (check-in: f5df83fd87 user: dan tags: experimental) | |
11:30 | Add tests to pager1.test and pagerfault.test. (check-in: 58c0b5bfed user: dan tags: experimental) | |
Changes
Changes to src/test_vfs.c.
︙ | ︙ | |||
55 56 57 58 59 60 61 62 63 64 65 66 67 68 | int isNoshm; int mask; int iIoerrCnt; int ioerr; int nIoerrFail; int iDevchar; int iSectorsize; }; /* ** The Testvfs.mask variable is set to a combination of the following. ** If a bit is clear in Testvfs.mask, then calls made by SQLite to the | > > > > | 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 | int isNoshm; int mask; int iIoerrCnt; int ioerr; int nIoerrFail; int iFullCnt; int fullerr; int nFullFail; int iDevchar; int iSectorsize; }; /* ** The Testvfs.mask variable is set to a combination of the following. ** If a bit is clear in Testvfs.mask, then calls made by SQLite to the |
︙ | ︙ | |||
189 190 191 192 193 194 195 196 197 198 199 200 201 202 | return 1; } } return 0; } static void tvfsExecTcl( Testvfs *p, const char *zMethod, Tcl_Obj *arg1, Tcl_Obj *arg2, Tcl_Obj *arg3 | > > > > > > > > > > > > > > > > > > > > > > > > | 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 | return 1; } } return 0; } static int tvfsInjectIoerr(Testvfs *p){ int ret = 0; if( p->ioerr ){ p->iIoerrCnt--; if( p->iIoerrCnt==0 || (p->iIoerrCnt<0 && p->ioerr==2) ){ ret = 1; p->nIoerrFail++; } } return ret; } static int tvfsInjectFullerr(Testvfs *p){ int ret = 0; if( p->fullerr ){ p->iFullCnt--; if( p->iFullCnt<=0 ){ ret = 1; p->nFullFail++; } } return ret; } static void tvfsExecTcl( Testvfs *p, const char *zMethod, Tcl_Obj *arg1, Tcl_Obj *arg2, Tcl_Obj *arg3 |
︙ | ︙ | |||
298 299 300 301 302 303 304 305 306 307 308 309 310 311 | if( p->pScript && p->mask&TESTVFS_WRITE_MASK ){ tvfsExecTcl(p, "xWrite", Tcl_NewStringObj(pFd->zFilename, -1), pFd->pShmId, 0 ); tvfsResultCode(p, &rc); } if( rc==SQLITE_OK ){ rc = sqlite3OsWrite(pFd->pReal, zBuf, iAmt, iOfst); } return rc; } | > > | 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 | if( p->pScript && p->mask&TESTVFS_WRITE_MASK ){ tvfsExecTcl(p, "xWrite", Tcl_NewStringObj(pFd->zFilename, -1), pFd->pShmId, 0 ); tvfsResultCode(p, &rc); } if( rc==SQLITE_OK && tvfsInjectFullerr(p) ) rc = SQLITE_FULL; if( rc==SQLITE_OK ){ rc = sqlite3OsWrite(pFd->pReal, zBuf, iAmt, iOfst); } return rc; } |
︙ | ︙ | |||
360 361 362 363 364 365 366 367 368 369 370 371 372 373 | tvfsExecTcl(p, "xSync", Tcl_NewStringObj(pFd->zFilename, -1), pFd->pShmId, Tcl_NewStringObj(zFlags, -1) ); tvfsResultCode(p, &rc); } if( rc==SQLITE_OK ){ rc = sqlite3OsSync(pFd->pReal, flags); } return rc; } | > > | 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 | tvfsExecTcl(p, "xSync", Tcl_NewStringObj(pFd->zFilename, -1), pFd->pShmId, Tcl_NewStringObj(zFlags, -1) ); tvfsResultCode(p, &rc); } if( rc==SQLITE_OK && tvfsInjectFullerr(p) ) rc = SQLITE_FULL; if( rc==SQLITE_OK ){ rc = sqlite3OsSync(pFd->pReal, flags); } return rc; } |
︙ | ︙ | |||
599 600 601 602 603 604 605 | /* ** Return the current time as a Julian Day number in *pTimeOut. */ static int tvfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ return PARENTVFS(pVfs)->xCurrentTime(PARENTVFS(pVfs), pTimeOut); } | < < < < < < < < < < < < | 631 632 633 634 635 636 637 638 639 640 641 642 643 644 | /* ** Return the current time as a Julian Day number in *pTimeOut. */ static int tvfsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ return PARENTVFS(pVfs)->xCurrentTime(PARENTVFS(pVfs), pTimeOut); } static int tvfsShmOpen( sqlite3_file *pFileDes ){ Testvfs *p; int rc = SQLITE_OK; /* Return code */ TestvfsBuffer *pBuffer; /* Buffer to open connection to */ TestvfsFile *pFd; /* The testvfs file structure */ |
︙ | ︙ | |||
828 829 830 831 832 833 834 | int objc, Tcl_Obj *CONST objv[] ){ Testvfs *p = (Testvfs *)cd; enum DB_enum { CMD_SHM, CMD_DELETE, CMD_FILTER, CMD_IOERR, CMD_SCRIPT, | | > | 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 | int objc, Tcl_Obj *CONST objv[] ){ Testvfs *p = (Testvfs *)cd; enum DB_enum { CMD_SHM, CMD_DELETE, CMD_FILTER, CMD_IOERR, CMD_SCRIPT, CMD_DEVCHAR, CMD_SECTORSIZE, CMD_FULLERR }; struct TestvfsSubcmd { char *zName; enum DB_enum eCmd; } aSubcmd[] = { { "shm", CMD_SHM }, { "delete", CMD_DELETE }, { "filter", CMD_FILTER }, { "ioerr", CMD_IOERR }, { "fullerr", CMD_FULLERR }, { "script", CMD_SCRIPT }, { "devchar", CMD_DEVCHAR }, { "sectorsize", CMD_SECTORSIZE }, { 0, 0 } }; int i; |
︙ | ︙ | |||
973 974 975 976 977 978 979 980 981 982 983 984 985 986 | } Tcl_ResetResult(interp); if( p->pScript ) Tcl_SetObjResult(interp, p->pScript); break; } /* ** TESTVFS ioerr ?IFAIL PERSIST? ** ** Where IFAIL is an integer and PERSIST is boolean. */ case CMD_IOERR: { | > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 | } Tcl_ResetResult(interp); if( p->pScript ) Tcl_SetObjResult(interp, p->pScript); break; } /* ** TESTVFS fullerr ?IFAIL? ** ** Where IFAIL is an integer. */ case CMD_FULLERR: { int iRet = p->nFullFail; p->nFullFail = 0; p->fullerr = 0; p->iFullCnt = 0; if( objc==3 ){ int iCnt; if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &iCnt) ){ return TCL_ERROR; } p->fullerr = (iCnt>0); p->iFullCnt = iCnt; }else if( objc!=2 ){ Tcl_AppendResult(interp, "Bad args", 0); return TCL_ERROR; } Tcl_SetObjResult(interp, Tcl_NewIntObj(iRet)); break; } /* ** TESTVFS ioerr ?IFAIL PERSIST? ** ** Where IFAIL is an integer and PERSIST is boolean. */ case CMD_IOERR: { |
︙ | ︙ |
Changes to test/malloc_common.tcl.
︙ | ︙ | |||
44 45 46 47 48 49 50 51 52 53 54 55 56 57 | -injecterrlist {{1 {disk I/O error}}} \ ] set FAULTSIM(ioerr-persistent) [list \ -injectstart {ioerr_injectstart 1} \ -injectstop ioerr_injectstop \ -injecterrlist {{1 {disk I/O error}}} \ ] # Transient and persistent SHM errors: # set FAULTSIM(shmerr-transient) [list \ -injectinstall shmerr_injectinstall \ -injectstart {shmerr_injectstart 0} \ -injectstop shmerr_injectstop \ | > > > > > > > > > > | 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 | -injecterrlist {{1 {disk I/O error}}} \ ] set FAULTSIM(ioerr-persistent) [list \ -injectstart {ioerr_injectstart 1} \ -injectstop ioerr_injectstop \ -injecterrlist {{1 {disk I/O error}}} \ ] # SQLITE_FULL errors (always persistent): # set FAULTSIM(full) [list \ -injectinstall fullerr_injectinstall \ -injectstart fullerr_injectstart \ -injectstop fullerr_injectstop \ -injecterrlist {{1 {database or disk is full}}} \ -injectuninstall fullerr_injectuninstall \ ] # Transient and persistent SHM errors: # set FAULTSIM(shmerr-transient) [list \ -injectinstall shmerr_injectinstall \ -injectstart {shmerr_injectstart 0} \ -injectstop shmerr_injectstop \ |
︙ | ︙ | |||
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 | set ::sqlite_io_error_persist 0 set ::sqlite_io_error_pending 0 set ::sqlite_io_error_hardhit 0 set ::sqlite_io_error_hit 0 set ::sqlite_io_error_pending 0 return $sv } # The following procs are used as [do_one_faultsim_test] callbacks when # injecting shared-memory related error faults into test cases. # proc shmerr_injectinstall {} { testvfs shmfault -default true } proc shmerr_injectuninstall {} { catch {db close} catch {db2 close} shmfault delete } proc shmerr_injectstart {persist iFail} { shmfault ioerr $iFail $persist } proc shmerr_injectstop {} { shmfault ioerr 0 0 } # This command is not called directly. It is used by the # [faultsim_test_result] command created by [do_faultsim_test] and used # by -test scripts. # proc faultsim_test_result_int {args} { upvar testrc testrc testresult testresult testnfail testnfail | > > > > > > > > > > > > > > > > > | 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 | set ::sqlite_io_error_persist 0 set ::sqlite_io_error_pending 0 set ::sqlite_io_error_hardhit 0 set ::sqlite_io_error_hit 0 set ::sqlite_io_error_pending 0 return $sv } # The following procs are used as [do_one_faultsim_test] callbacks when # injecting shared-memory related error faults into test cases. # proc shmerr_injectinstall {} { testvfs shmfault -default true } proc shmerr_injectuninstall {} { catch {db close} catch {db2 close} shmfault delete } proc shmerr_injectstart {persist iFail} { shmfault ioerr $iFail $persist } proc shmerr_injectstop {} { shmfault ioerr 0 0 } proc fullerr_injectinstall {} { testvfs shmfault -default true } proc fullerr_injectuninstall {} { catch {db close} catch {db2 close} shmfault delete } proc fullerr_injectstart {iFail} { shmfault full $iFail } proc fullerr_injectstop {} { shmfault full 0 } # This command is not called directly. It is used by the # [faultsim_test_result] command created by [do_faultsim_test] and used # by -test scripts. # proc faultsim_test_result_int {args} { upvar testrc testrc testresult testresult testnfail testnfail |
︙ | ︙ |
Changes to test/pager1.test.
︙ | ︙ | |||
22 23 24 25 26 27 28 29 30 31 32 33 34 35 | # # pager1-3.*: Savepoint related tests. # # pager1-4.*: Hot-journal related tests. # # pager1-5.*: Cases related to multi-file commits. # proc do_execsql_test {testname sql result} { uplevel do_test $testname [list "execsql {$sql}"] [list $result] } proc do_catchsql_test {testname sql result} { uplevel do_test $testname [list "catchsql {$sql}"] [list $result] } | > > | 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | # # pager1-3.*: Savepoint related tests. # # pager1-4.*: Hot-journal related tests. # # pager1-5.*: Cases related to multi-file commits. # # pager1-6.*: Cases related to "PRAGMA max_page_count" # proc do_execsql_test {testname sql result} { uplevel do_test $testname [list "execsql {$sql}"] [list $result] } proc do_catchsql_test {testname sql result} { uplevel do_test $testname [list "catchsql {$sql}"] [list $result] } |
︙ | ︙ | |||
217 218 219 220 221 222 223 224 225 226 227 228 229 230 | set otn 0 testvfs tv -default 1 foreach code [list { set s 512 } { set s 1024 set sql { PRAGMA journal_mode = memory } } { set s 2048 tv devchar safe_append } { set s 4096 } { set s 4096 | > > > > > > | 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 | set otn 0 testvfs tv -default 1 foreach code [list { set s 512 } { set s 1024 set sql { PRAGMA journal_mode = memory } } { set s 1024 set sql { PRAGMA journal_mode = memory; PRAGMA locking_mode = exclusive; } } { set s 2048 tv devchar safe_append } { set s 4096 } { set s 4096 |
︙ | ︙ | |||
445 446 447 448 449 450 451 452 453 454 455 | hexio_write test.db-journal $ofst [format %.8x $value] execsql { SELECT * FROM t1 } } $result } db close #------------------------------------------------------------------------- # finish_test | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 | hexio_write test.db-journal $ofst [format %.8x $value] execsql { SELECT * FROM t1 } } $result } db close #------------------------------------------------------------------------- # The following tests deal with multi-file commits. # # pager1-5.1.*: The case where a multi-file cannot be committed because # another connection is holding a SHARED lock on one of the # files. After the SHARED lock is removed, the COMMIT succeeds. # # pager1-5.2.*: Multi-file commits with journal_mode=memory. # # pager1-5.3.*: Multi-file commits with journal_mode=memory. # # pager1-5.4.*: Check that with synchronous=normal, the master-journal file # name is added to a journal file immediately after the last # journal record. But with synchronous=full, extra unused space # is allocated between the last journal record and the # master-journal file name so that the master-journal file # name does not lie on the same sector as the last journal file # record. # # pager1-5.5.*: # do_test pager1-5.1.1 { faultsim_delete_and_reopen execsql { ATTACH 'test.db2' AS aux; CREATE TABLE t1(a, b); CREATE TABLE aux.t2(a, b); INSERT INTO t1 VALUES(17, 'Lenin'); INSERT INTO t1 VALUES(22, 'Stalin'); INSERT INTO t1 VALUES(53, 'Khrushchev'); } } {} do_test pager1-5.1.2 { execsql { BEGIN; INSERT INTO t1 VALUES(64, 'Brezhnev'); INSERT INTO t2 SELECT * FROM t1; } sqlite3 db2 test.db2 execsql { BEGIN; SELECT * FROM t2; } db2 } {} do_test pager1-5.1.3 { catchsql COMMIT } {1 {database is locked}} do_test pager1-5.1.4 { execsql COMMIT db2 execsql COMMIT execsql { SELECT * FROM t2 } db2 } {17 Lenin 22 Stalin 53 Khrushchev 64 Brezhnev} do_test pager1-5.1.5 { db2 close } {} do_test pager1-5.2.1 { execsql { PRAGMA journal_mode = memory; BEGIN; INSERT INTO t1 VALUES(84, 'Andropov'); INSERT INTO t2 VALUES(84, 'Andropov'); COMMIT; } } {memory} do_test pager1-5.3.1 { execsql { PRAGMA journal_mode = off; BEGIN; INSERT INTO t1 VALUES(85, 'Gorbachev'); INSERT INTO t2 VALUES(85, 'Gorbachev'); COMMIT; } } {off} do_test pager1-5.4.1 { db close testvfs tv sqlite3 db test.db -vfs tv execsql { ATTACH 'test.db2' AS aux } tv filter xDelete tv script max_journal_size tv sectorsize 512 set ::max_journal 0 proc max_journal_size {method args} { set sz 0 catch { set sz [file size test.db-journal] } if {$sz > $::max_journal} { set ::max_journal $sz } return SQLITE_OK } execsql { PRAGMA journal_mode = DELETE; PRAGMA synchronous = NORMAL; BEGIN; INSERT INTO t1 VALUES(85, 'Gorbachev'); INSERT INTO t2 VALUES(85, 'Gorbachev'); COMMIT; } set ::max_journal } [expr 2615+[string length [pwd]]] do_test pager1-5.4.2 { set ::max_journal 0 execsql { PRAGMA synchronous = full; BEGIN; DELETE FROM t1 WHERE b = 'Lenin'; DELETE FROM t2 WHERE b = 'Lenin'; COMMIT; } set ::max_journal } [expr 3111+[string length [pwd]]] db close tv delete do_test pager1-5.5.1 { sqlite3 db test.db execsql { ATTACH 'test.db2' AS aux; PRAGMA journal_mode = PERSIST; CREATE TABLE t3(a, b); INSERT INTO t3 SELECT randomblob(1500), randomblob(1500) FROM t1; UPDATE t3 SET b = randomblob(1500); } expr [file size test.db-journal] > 15000 } {1} do_test pager1-5.5.2 { execsql { PRAGMA synchronous = full; BEGIN; DELETE FROM t1 WHERE b = 'Stalin'; DELETE FROM t2 WHERE b = 'Stalin'; COMMIT; } file size test.db-journal } {0} #------------------------------------------------------------------------- # The following tests work with "PRAGMA max_page_count" # do_test pager1-6.1 { faultsim_delete_and_reopen execsql { PRAGMA max_page_count = 10; CREATE TABLE t2(a, b); CREATE TABLE t3(a, b); CREATE TABLE t4(a, b); CREATE TABLE t5(a, b); CREATE TABLE t6(a, b); CREATE TABLE t7(a, b); CREATE TABLE t8(a, b); CREATE TABLE t9(a, b); CREATE TABLE t10(a, b); } } {10} do_test pager1-6.2 { catchsql { CREATE TABLE t11(a, b); } } {1 {database or disk is full}} finish_test |
Changes to test/pagerfault.test.
︙ | ︙ | |||
175 176 177 178 179 180 181 182 183 184 185 186 187 188 | } -test { faultsim_test_result {0 z} faultsim_integrity_check } #------------------------------------------------------------------------- # Test fault-injection as part of a commit when using journal_mode=PERSIST. # do_test pagerfault-5-pre1 { faultsim_delete_and_reopen db func a_string a_string execsql { CREATE TABLE t1(a UNIQUE, b UNIQUE); INSERT INTO t1 VALUES(a_string(200), a_string(300)); | > > > > > > | 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 | } -test { faultsim_test_result {0 z} faultsim_integrity_check } #------------------------------------------------------------------------- # Test fault-injection as part of a commit when using journal_mode=PERSIST. # Three different cases: # # pagerfault-5.1: With no journal_size_limit configured. # pagerfault-5.2: With a journal_size_limit configured. # pagerfault-5.4: Multi-file transaction. One connection has a # journal_size_limit of 0, the other has no limit. # do_test pagerfault-5-pre1 { faultsim_delete_and_reopen db func a_string a_string execsql { CREATE TABLE t1(a UNIQUE, b UNIQUE); INSERT INTO t1 VALUES(a_string(200), a_string(300)); |
︙ | ︙ | |||
210 211 212 213 214 215 216 | } } -body { execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } | < > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 | } } -body { execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } do_faultsim_test pagerfault-5.3 -prep { faultsim_restore_and_reopen db func a_string a_string file delete -force test2.db test2.db-journal test2.db-wal execsql { PRAGMA journal_mode = PERSIST; ATTACH 'test2.db' AS aux; PRAGMA aux.journal_mode = PERSIST; PRAGMA aux.journal_size_limit = 0; } } -body { execsql { BEGIN; INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1; CREATE TABLE aux.t2 AS SELECT * FROM t1; COMMIT; } } -test { faultsim_test_result {0 {}} } # The following was an attempt to get a bitvec malloc to fail. Didn't work. # # do_test pagerfault-6-pre1 { # faultsim_delete_and_reopen # execsql { # CREATE TABLE t1(x, y, UNIQUE(x, y)); # INSERT INTO t1 VALUES(1, randomblob(1501)); # INSERT INTO t1 VALUES(2, randomblob(1502)); # INSERT INTO t1 VALUES(3, randomblob(1503)); # INSERT INTO t1 VALUES(4, randomblob(1504)); # INSERT INTO t1 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1; # INSERT INTO t1 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1; # INSERT INTO t1 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1; # INSERT INTO t1 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1; # } # faultsim_save_and_close # } {} # do_faultsim_test pagerfault-6 -prep { # faultsim_restore_and_reopen # } -body { # execsql { # BEGIN; # UPDATE t1 SET x=x+4 WHERE x=1; # SAVEPOINT one; # UPDATE t1 SET x=x+4 WHERE x=2; # SAVEPOINT three; # UPDATE t1 SET x=x+4 WHERE x=3; # SAVEPOINT four; # UPDATE t1 SET x=x+4 WHERE x=4; # RELEASE three; # COMMIT; # SELECT DISTINCT x FROM t1; # } # } -test { # faultsim_test_result {0 {5 6 7 8}} # faultsim_integrity_check # } finish_test |
Changes to test/permutations.test.
︙ | ︙ | |||
166 167 168 169 170 171 172 173 174 175 176 177 178 179 | } test_suite "coverage-pager" -description { Coverage tests for file pager.c. } -files { pager1.test pagerfault.test } lappend ::testsuitelist xxx #------------------------------------------------------------------------- # Define the permutation test suites: # | > | 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 | } test_suite "coverage-pager" -description { Coverage tests for file pager.c. } -files { pager1.test pagerfault.test journal2.test } lappend ::testsuitelist xxx #------------------------------------------------------------------------- # Define the permutation test suites: # |
︙ | ︙ |