Annotation of embedaddon/sqlite3/test/indexfault.test, revision 1.1
1.1 ! misho 1: # 2011 August 08
! 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/malloc_common.tcl
! 17:
! 18: ifcapable !mergesort {
! 19: finish_test
! 20: return
! 21: }
! 22:
! 23: set testprefix indexfault
! 24:
! 25: # Set up the custom fault-injector. This is further configured by using
! 26: # different values for $::custom_filter and different implementations
! 27: # of Tcl proc [xCustom] for each test case.
! 28: #
! 29: proc install_custom_faultsim {} {
! 30: set ::FAULTSIM(custom) [list \
! 31: -injectinstall custom_injectinstall \
! 32: -injectstart custom_injectstart \
! 33: -injectstop custom_injectstop \
! 34: -injecterrlist {{1 {disk I/O error}}} \
! 35: -injectuninstall custom_injectuninstall \
! 36: ]
! 37: proc custom_injectinstall {} {
! 38: testvfs shmfault -default true
! 39: shmfault filter $::custom_filter
! 40: shmfault script xCustom
! 41: }
! 42: proc custom_injectuninstall {} {
! 43: catch {db close}
! 44: catch {db2 close}
! 45: shmfault delete
! 46: }
! 47: set ::custom_ifail -1
! 48: set ::custom_nfail -1
! 49: proc custom_injectstart {iFail} {
! 50: set ::custom_ifail $iFail
! 51: set ::custom_nfail 0
! 52: }
! 53: proc custom_injectstop {} {
! 54: set ::custom_ifail -1
! 55: return $::custom_nfail
! 56: }
! 57: }
! 58: proc uninstall_custom_faultsim {} {
! 59: unset -nocomplain ::FAULTSIM(custom)
! 60: }
! 61:
! 62:
! 63: #-------------------------------------------------------------------------
! 64: # These tests - indexfault-1.* - Build an index on a smallish table with
! 65: # all different kinds of fault-injection. The CREATE INDEX is run once
! 66: # with default options and once with a 50KB soft-heap-limit.
! 67: #
! 68: do_execsql_test 1.0 {
! 69: BEGIN;
! 70: CREATE TABLE t1(x);
! 71: INSERT INTO t1 VALUES(randomblob(202));
! 72: INSERT INTO t1 SELECT randomblob(202) FROM t1; -- 2
! 73: INSERT INTO t1 SELECT randomblob(202) FROM t1; -- 4
! 74: INSERT INTO t1 SELECT randomblob(202) FROM t1; -- 8
! 75: INSERT INTO t1 SELECT randomblob(202) FROM t1; -- 16
! 76: INSERT INTO t1 SELECT randomblob(202) FROM t1; -- 32
! 77: INSERT INTO t1 SELECT randomblob(202) FROM t1; -- 64
! 78: INSERT INTO t1 SELECT randomblob(202) FROM t1; -- 128
! 79: INSERT INTO t1 SELECT randomblob(202) FROM t1; -- 256
! 80: COMMIT;
! 81: }
! 82: faultsim_save_and_close
! 83:
! 84: do_faultsim_test 1.1 -prep {
! 85: faultsim_restore_and_reopen
! 86: } -body {
! 87: execsql { CREATE INDEX i1 ON t1(x) }
! 88: faultsim_test_result {0 {}}
! 89: faultsim_integrity_check
! 90: }
! 91: ifcapable memorymanage {
! 92: set soft_limit [sqlite3_soft_heap_limit 50000]
! 93: do_faultsim_test 2.1 -prep {
! 94: faultsim_restore_and_reopen
! 95: } -body {
! 96: execsql { CREATE INDEX i1 ON t1(x) }
! 97: faultsim_test_result {0 {}}
! 98: }
! 99: sqlite3_soft_heap_limit $soft_limit
! 100: }
! 101:
! 102: #-------------------------------------------------------------------------
! 103: # These are similar to the indexfault-1.* tests, except they create an
! 104: # index with more than one column.
! 105: #
! 106: sqlite3 db test.db
! 107: do_execsql_test 2.0 {
! 108: BEGIN;
! 109: DROP TABLE IF EXISTS t1;
! 110: CREATE TABLE t1(t,u,v,w,x,y,z);
! 111: INSERT INTO t1 VALUES(
! 112: randomblob(30), randomblob(30), randomblob(30), randomblob(30),
! 113: randomblob(30), randomblob(30), randomblob(30)
! 114: );
! 115: INSERT INTO t1 SELECT
! 116: randomblob(30), randomblob(30), randomblob(30), randomblob(30),
! 117: randomblob(30), randomblob(30), randomblob(30) FROM t1; -- 2
! 118: INSERT INTO t1 SELECT
! 119: randomblob(30), randomblob(30), randomblob(30), randomblob(30),
! 120: randomblob(30), randomblob(30), randomblob(30) FROM t1; -- 4
! 121: INSERT INTO t1 SELECT
! 122: randomblob(30), randomblob(30), randomblob(30), randomblob(30),
! 123: randomblob(30), randomblob(30), randomblob(30) FROM t1; -- 8
! 124: INSERT INTO t1 SELECT
! 125: randomblob(30), randomblob(30), randomblob(30), randomblob(30),
! 126: randomblob(30), randomblob(30), randomblob(30) FROM t1; -- 16
! 127: INSERT INTO t1 SELECT
! 128: randomblob(30), randomblob(30), randomblob(30), randomblob(30),
! 129: randomblob(30), randomblob(30), randomblob(30) FROM t1; -- 32
! 130: INSERT INTO t1 SELECT
! 131: randomblob(30), randomblob(30), randomblob(30), randomblob(30),
! 132: randomblob(30), randomblob(30), randomblob(30) FROM t1; -- 64
! 133: INSERT INTO t1 SELECT
! 134: randomblob(30), randomblob(30), randomblob(30), randomblob(30),
! 135: randomblob(30), randomblob(30), randomblob(30) FROM t1; -- 128
! 136: COMMIT;
! 137: }
! 138: faultsim_save_and_close
! 139:
! 140: do_faultsim_test 2.1 -prep {
! 141: faultsim_restore_and_reopen
! 142: } -body {
! 143: execsql { CREATE INDEX i1 ON t1(t,u,v,w,x,y,z) }
! 144: faultsim_test_result {0 {}}
! 145: faultsim_integrity_check
! 146: }
! 147: ifcapable memorymanage {
! 148: set soft_limit [sqlite3_soft_heap_limit 50000]
! 149: do_faultsim_test 2.2 -prep {
! 150: faultsim_restore_and_reopen
! 151: } -body {
! 152: execsql { CREATE INDEX i1 ON t1(t,u,v,w,x,y,z) }
! 153: faultsim_test_result {0 {}}
! 154: }
! 155: sqlite3_soft_heap_limit $soft_limit
! 156: }
! 157:
! 158: #-------------------------------------------------------------------------
! 159: # The following tests - indexfault-2.* - all attempt to build a index
! 160: # on table t1 in the main database with injected IO errors. Individual
! 161: # test cases work as follows:
! 162: #
! 163: # 3.1: IO errors injected into xOpen() calls.
! 164: # 3.2: As 7.1, but with a low (50KB) soft-heap-limit.
! 165: #
! 166: # 3.3: IO errors injected into the first 200 write() calls made on the
! 167: # second temporary file.
! 168: # 3.4: As 7.3, but with a low (50KB) soft-heap-limit.
! 169: #
! 170: # 3.5: After a certain amount of data has been read from the main database
! 171: # file (and written into the temporary b-tree), sqlite3_release_memory()
! 172: # is called to free as much memory as possible. This causes the temp
! 173: # b-tree to be flushed to disk. So that before its contents can be
! 174: # transfered to a PMA they must be read back from disk - creating extra
! 175: # opportunities for IO errors.
! 176: #
! 177: install_custom_faultsim
! 178:
! 179: # Set up a table to build indexes on. Save the setup using the
! 180: # [faultsim_save_and_close] mechanism.
! 181: #
! 182: sqlite3 db test.db
! 183: do_execsql_test 3.0 {
! 184: BEGIN;
! 185: DROP TABLE IF EXISTS t1;
! 186: CREATE TABLE t1(x);
! 187: INSERT INTO t1 VALUES(randomblob(11000));
! 188: INSERT INTO t1 SELECT randomblob(11001) FROM t1; -- 2
! 189: INSERT INTO t1 SELECT randomblob(11002) FROM t1; -- 4
! 190: INSERT INTO t1 SELECT randomblob(11003) FROM t1; -- 8
! 191: INSERT INTO t1 SELECT randomblob(11004) FROM t1; -- 16
! 192: INSERT INTO t1 SELECT randomblob(11005) FROM t1; -- 32
! 193: INSERT INTO t1 SELECT randomblob(11006) FROM t1; -- 64
! 194: INSERT INTO t1 SELECT randomblob(11007) FROM t1; -- 128
! 195: INSERT INTO t1 SELECT randomblob(11008) FROM t1; -- 256
! 196: INSERT INTO t1 SELECT randomblob(11009) FROM t1; -- 512
! 197: COMMIT;
! 198: }
! 199: faultsim_save_and_close
! 200:
! 201: set ::custom_filter xOpen
! 202: proc xCustom {args} {
! 203: incr ::custom_ifail -1
! 204: if {$::custom_ifail==0} {
! 205: incr ::custom_nfail
! 206: return "SQLITE_IOERR"
! 207: }
! 208: return "SQLITE_OK"
! 209: }
! 210: do_faultsim_test 3.1 -faults custom -prep {
! 211: faultsim_restore_and_reopen
! 212: } -body {
! 213: execsql { CREATE INDEX i1 ON t1(x) }
! 214: faultsim_test_result {0 {}}
! 215: }
! 216: ifcapable memorymanage {
! 217: set soft_limit [sqlite3_soft_heap_limit 50000]
! 218: do_faultsim_test 3.2 -faults custom -prep {
! 219: faultsim_restore_and_reopen
! 220: } -body {
! 221: execsql { CREATE INDEX i1 ON t1(x) }
! 222: faultsim_test_result {0 {}}
! 223: }
! 224: sqlite3_soft_heap_limit $soft_limit
! 225: }
! 226:
! 227: set ::custom_filter {xOpen xWrite}
! 228: proc xCustom {method args} {
! 229: if {$method == "xOpen"} {
! 230: if {[lindex $args 0] == ""} {
! 231: incr ::nTmpOpen 1
! 232: if {$::nTmpOpen == 3} { return "failme" }
! 233: }
! 234: return "SQLITE_OK"
! 235: }
! 236: if {$::custom_ifail<200 && [lindex $args 1] == "failme"} {
! 237: incr ::custom_ifail -1
! 238: if {$::custom_ifail==0} {
! 239: incr ::custom_nfail
! 240: return "SQLITE_IOERR"
! 241: }
! 242: }
! 243: return "SQLITE_OK"
! 244: }
! 245:
! 246: do_faultsim_test 3.3 -faults custom -prep {
! 247: faultsim_restore_and_reopen
! 248: set ::nTmpOpen 0
! 249: } -body {
! 250: execsql { CREATE INDEX i1 ON t1(x) }
! 251: faultsim_test_result {0 {}}
! 252: }
! 253:
! 254: ifcapable memorymanage {
! 255: set soft_limit [sqlite3_soft_heap_limit 50000]
! 256: do_faultsim_test 3.4 -faults custom -prep {
! 257: faultsim_restore_and_reopen
! 258: set ::nTmpOpen 0
! 259: } -body {
! 260: execsql { CREATE INDEX i1 ON t1(x) }
! 261: faultsim_test_result {0 {}}
! 262: }
! 263: sqlite3_soft_heap_limit $soft_limit
! 264: }
! 265:
! 266: uninstall_custom_faultsim
! 267:
! 268: #-------------------------------------------------------------------------
! 269: # Test 4: After a certain amount of data has been read from the main database
! 270: # file (and written into the temporary b-tree), sqlite3_release_memory() is
! 271: # called to free as much memory as possible. This causes the temp b-tree to be
! 272: # flushed to disk. So that before its contents can be transfered to a PMA they
! 273: # must be read back from disk - creating extra opportunities for IO errors.
! 274: #
! 275: install_custom_faultsim
! 276:
! 277: catch { db close }
! 278: forcedelete test.db
! 279: sqlite3 db test.db
! 280:
! 281: do_execsql_test 4.0 {
! 282: BEGIN;
! 283: DROP TABLE IF EXISTS t1;
! 284: CREATE TABLE t1(x);
! 285: INSERT INTO t1 VALUES(randomblob(11000));
! 286: INSERT INTO t1 SELECT randomblob(11001) FROM t1; -- 2
! 287: INSERT INTO t1 SELECT randomblob(11002) FROM t1; -- 4
! 288: INSERT INTO t1 SELECT randomblob(11003) FROM t1; -- 8
! 289: INSERT INTO t1 SELECT randomblob(11004) FROM t1; -- 16
! 290: INSERT INTO t1 SELECT randomblob(11005) FROM t1; -- 32
! 291: INSERT INTO t1 SELECT randomblob(11005) FROM t1; -- 64
! 292: COMMIT;
! 293: }
! 294: faultsim_save_and_close
! 295:
! 296: testvfs tvfs
! 297: tvfs script xRead
! 298: tvfs filter xRead
! 299: set ::nRead 0
! 300: proc xRead {method file args} {
! 301: if {[file tail $file] == "test.db"} { incr ::nRead }
! 302: }
! 303:
! 304: do_test 4.1 {
! 305: sqlite3 db test.db -vfs tvfs
! 306: execsql { CREATE INDEX i1 ON t1(x) }
! 307: } {}
! 308:
! 309: db close
! 310: tvfs delete
! 311:
! 312: set ::custom_filter xRead
! 313: proc xCustom {method file args} {
! 314: incr ::nReadCall
! 315: if {$::nReadCall >= ($::nRead/5)} {
! 316: if {$::nReadCall == ($::nRead/5)} {
! 317: set nByte [sqlite3_release_memory [expr 64*1024*1024]]
! 318: sqlite3_soft_heap_limit 20000
! 319: }
! 320: if {$file == ""} {
! 321: incr ::custom_ifail -1
! 322: if {$::custom_ifail==0} {
! 323: incr ::custom_nfail
! 324: return "SQLITE_IOERR"
! 325: }
! 326: }
! 327: }
! 328: return "SQLITE_OK"
! 329: }
! 330:
! 331: do_faultsim_test 4.2 -faults custom -prep {
! 332: faultsim_restore_and_reopen
! 333: set ::nReadCall 0
! 334: sqlite3_soft_heap_limit 0
! 335: } -body {
! 336: execsql { CREATE INDEX i1 ON t1(x) }
! 337: faultsim_test_result {0 {}}
! 338: }
! 339:
! 340: uninstall_custom_faultsim
! 341:
! 342: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to indexfault.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