Annotation of embedaddon/sqlite3/test/corruptC.test, revision 1.1
1.1 ! misho 1: # 2004 August 30
! 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.
! 12: #
! 13: # This file implements tests to make sure SQLite does not crash or
! 14: # segfault if it sees a corrupt database file. It creates a base
! 15: # data base file, then tests that single byte corruptions in
! 16: # increasingly larger quantities are handled gracefully.
! 17: #
! 18: # $Id: corruptC.test,v 1.14 2009/07/11 06:55:34 danielk1977 Exp $
! 19:
! 20: catch {forcedelete test.db test.db-journal test.bu}
! 21:
! 22: set testdir [file dirname $argv0]
! 23: source $testdir/tester.tcl
! 24:
! 25: # Do not use a codec for tests in this file, as the database file is
! 26: # manipulated directly using tcl scripts (using the [hexio_write] command).
! 27: #
! 28: do_not_use_codec
! 29:
! 30: # Construct a compact, dense database for testing.
! 31: #
! 32: do_test corruptC-1.1 {
! 33: execsql {
! 34: PRAGMA auto_vacuum = 0;
! 35: PRAGMA legacy_file_format=1;
! 36: BEGIN;
! 37: CREATE TABLE t1(x,y);
! 38: INSERT INTO t1 VALUES(1,1);
! 39: INSERT OR IGNORE INTO t1 SELECT x*2,y FROM t1;
! 40: INSERT OR IGNORE INTO t1 SELECT x*3,y FROM t1;
! 41: INSERT OR IGNORE INTO t1 SELECT x*5,y FROM t1;
! 42: INSERT OR IGNORE INTO t1 SELECT x*7,y FROM t1;
! 43: INSERT OR IGNORE INTO t1 SELECT x*11,y FROM t1;
! 44: INSERT OR IGNORE INTO t1 SELECT x*13,y FROM t1;
! 45: CREATE INDEX t1i1 ON t1(x);
! 46: CREATE TABLE t2 AS SELECT x,2 as y FROM t1 WHERE rowid%5!=0;
! 47: COMMIT;
! 48: }
! 49: } {}
! 50:
! 51: ifcapable {integrityck} {
! 52: integrity_check corruptC-1.2
! 53: }
! 54:
! 55: # Generate random integer
! 56: #
! 57: proc random {range} {
! 58: return [expr {round(rand()*$range)}]
! 59: }
! 60:
! 61: # Setup for the tests. Make a backup copy of the good database in test.bu.
! 62: #
! 63: db close
! 64: forcecopy test.db test.bu
! 65: sqlite3 db test.db
! 66: set fsize [file size test.db]
! 67:
! 68: # Set a quasi-random random seed.
! 69: if {[info exists ::G(issoak)]} {
! 70: # If we are doing SOAK tests, we want a different
! 71: # random seed for each run. Ideally we would like
! 72: # to use [clock clicks] or something like that here.
! 73: set qseed [file mtime test.db]
! 74: } else {
! 75: # If we are not doing soak tests,
! 76: # make it repeatable.
! 77: set qseed 0
! 78: }
! 79: expr srand($qseed)
! 80:
! 81: #
! 82: # First test some specific corruption tests found from earlier runs
! 83: # with specific seeds.
! 84: #
! 85:
! 86: # test that a corrupt content offset size is handled (seed 5577)
! 87: do_test corruptC-2.1 {
! 88: db close
! 89: forcecopy test.bu test.db
! 90:
! 91: # insert corrupt byte(s)
! 92: hexio_write test.db 2053 [format %02x 0x04]
! 93:
! 94: sqlite3 db test.db
! 95: catchsql {PRAGMA integrity_check}
! 96: } {1 {database disk image is malformed}}
! 97:
! 98: # test that a corrupt content offset size is handled (seed 5649)
! 99: do_test corruptC-2.2 {
! 100: db close
! 101: forcecopy test.bu test.db
! 102:
! 103: # insert corrupt byte(s)
! 104: hexio_write test.db 27 [format %02x 0x08]
! 105: hexio_write test.db 233 [format %02x 0x6a]
! 106: hexio_write test.db 328 [format %02x 0x67]
! 107: hexio_write test.db 750 [format %02x 0x1f]
! 108: hexio_write test.db 1132 [format %02x 0x52]
! 109: hexio_write test.db 1133 [format %02x 0x84]
! 110: hexio_write test.db 1220 [format %02x 0x01]
! 111: hexio_write test.db 3688 [format %02x 0xc1]
! 112: hexio_write test.db 3714 [format %02x 0x58]
! 113: hexio_write test.db 3746 [format %02x 0x9a]
! 114:
! 115: sqlite3 db test.db
! 116: catchsql {UPDATE t1 SET y=1}
! 117: } {1 {database disk image is malformed}}
! 118:
! 119: # test that a corrupt free cell size is handled (seed 13329)
! 120: do_test corruptC-2.3 {
! 121: db close
! 122: forcecopy test.bu test.db
! 123:
! 124: # insert corrupt byte(s)
! 125: hexio_write test.db 1094 [format %02x 0x76]
! 126:
! 127: sqlite3 db test.db
! 128: catchsql {UPDATE t1 SET y=1}
! 129: } {1 {database disk image is malformed}}
! 130:
! 131: # test that a corrupt free cell size is handled (seed 169571)
! 132: do_test corruptC-2.4 {
! 133: db close
! 134: forcecopy test.bu test.db
! 135:
! 136: # insert corrupt byte(s)
! 137: hexio_write test.db 3119 [format %02x 0xdf]
! 138:
! 139: sqlite3 db test.db
! 140: catchsql {UPDATE t2 SET y='abcdef-uvwxyz'}
! 141: } {1 {database disk image is malformed}}
! 142:
! 143: # test that a corrupt free cell size is handled (seed 169571)
! 144: do_test corruptC-2.5 {
! 145: db close
! 146: forcecopy test.bu test.db
! 147:
! 148: # insert corrupt byte(s)
! 149: hexio_write test.db 3119 [format %02x 0xdf]
! 150: hexio_write test.db 4073 [format %02x 0xbf]
! 151:
! 152: sqlite3 db test.db
! 153: catchsql {BEGIN; UPDATE t2 SET y='abcdef-uvwxyz'; ROLLBACK;}
! 154: catchsql {PRAGMA integrity_check}
! 155: } {0 {{*** in database main ***
! 156: Page 4: btreeInitPage() returns error code 11}}}
! 157:
! 158: # {0 {{*** in database main ***
! 159: # Corruption detected in cell 710 on page 4
! 160: # Multiple uses for byte 661 of page 4
! 161: # Fragmented space is 249 byte reported as 21 on page 4}}}
! 162:
! 163: # test that a corrupt free cell size is handled (seed 169595)
! 164: do_test corruptC-2.6 {
! 165: db close
! 166: forcecopy test.bu test.db
! 167:
! 168: # insert corrupt byte(s)
! 169: hexio_write test.db 619 [format %02x 0xe2]
! 170: hexio_write test.db 3150 [format %02x 0xa8]
! 171:
! 172: sqlite3 db test.db
! 173: catchsql {BEGIN; UPDATE t2 SET y='abcdef-uvwxyz'; ROLLBACK;}
! 174: } {1 {database disk image is malformed}}
! 175:
! 176: # corruption (seed 178692)
! 177: do_test corruptC-2.7 {
! 178: db close
! 179: forcecopy test.bu test.db
! 180:
! 181: # insert corrupt byte(s)
! 182: hexio_write test.db 3074 [format %02x 0xa0]
! 183:
! 184: sqlite3 db test.db
! 185: catchsql {BEGIN; UPDATE t2 SET y='abcdef-uvwxyz'; ROLLBACK;}
! 186: } {1 {database disk image is malformed}}
! 187:
! 188: # corruption (seed 179069)
! 189: do_test corruptC-2.8 {
! 190: db close
! 191: forcecopy test.bu test.db
! 192:
! 193: # insert corrupt byte(s)
! 194: hexio_write test.db 1393 [format %02x 0x7d]
! 195: hexio_write test.db 84 [format %02x 0x19]
! 196: hexio_write test.db 3287 [format %02x 0x3b]
! 197: hexio_write test.db 2564 [format %02x 0xed]
! 198: hexio_write test.db 2139 [format %02x 0x55]
! 199:
! 200: sqlite3 db test.db
! 201: catchsql {BEGIN; DELETE FROM t1 WHERE x>13; ROLLBACK;}
! 202: } {1 {database disk image is malformed}}
! 203:
! 204: # corruption (seed 170434)
! 205: do_test corruptC-2.9 {
! 206: db close
! 207: forcecopy test.bu test.db
! 208:
! 209: # insert corrupt byte(s)
! 210: hexio_write test.db 2095 [format %02x 0xd6]
! 211:
! 212: sqlite3 db test.db
! 213: catchsql {BEGIN; DELETE FROM t1 WHERE x>13; ROLLBACK;}
! 214: } {1 {database disk image is malformed}}
! 215:
! 216: # corruption (seed 186504)
! 217: do_test corruptC-2.10 {
! 218: db close
! 219: forcecopy test.bu test.db
! 220:
! 221: # insert corrupt byte(s)
! 222: hexio_write test.db 3130 [format %02x 0x02]
! 223:
! 224: sqlite3 db test.db
! 225: catchsql {BEGIN; UPDATE t2 SET y='abcdef-uvwxyz'; ROLLBACK;}
! 226: } {1 {database disk image is malformed}}
! 227:
! 228: # corruption (seed 1589)
! 229: do_test corruptC-2.11 {
! 230: db close
! 231: forcecopy test.bu test.db
! 232:
! 233: # insert corrupt byte(s)
! 234: hexio_write test.db 55 [format %02x 0xa7]
! 235:
! 236: sqlite3 db test.db
! 237: catchsql {BEGIN; CREATE TABLE t3 AS SELECT x,3 as y FROM t2 WHERE rowid%5!=0; ROLLBACK;}
! 238: } {1 {database disk image is malformed}}
! 239:
! 240: # corruption (seed 14166)
! 241: do_test corruptC-2.12 {
! 242: db close
! 243: forcecopy test.bu test.db
! 244:
! 245: # insert corrupt byte(s)
! 246: hexio_write test.db 974 [format %02x 0x2e]
! 247:
! 248: sqlite3 db test.db
! 249: catchsql {SELECT count(*) FROM sqlite_master;}
! 250: } {1 {malformed database schema (t1i1) - corrupt database}}
! 251:
! 252: # corruption (seed 218803)
! 253: do_test corruptC-2.13 {
! 254: db close
! 255: forcecopy test.bu test.db
! 256:
! 257: # insert corrupt byte(s)
! 258: hexio_write test.db 102 [format %02x 0x12]
! 259:
! 260: sqlite3 db test.db
! 261: catchsql {BEGIN; CREATE TABLE t3 AS SELECT x,3 as y FROM t2 WHERE rowid%5!=0; ROLLBACK;}
! 262: } {1 {database disk image is malformed}}
! 263:
! 264: do_test corruptC-2.14 {
! 265: db close
! 266: forcecopy test.bu test.db
! 267:
! 268: sqlite3 db test.db
! 269: set blob [string repeat abcdefghij 10000]
! 270: execsql { INSERT INTO t1 VALUES (1, $blob) }
! 271:
! 272: sqlite3 db test.db
! 273: set filesize [file size test.db]
! 274: hexio_write test.db [expr $filesize-2048] 00000001
! 275: catchsql {DELETE FROM t1 WHERE rowid = (SELECT max(rowid) FROM t1)}
! 276: } {1 {database disk image is malformed}}
! 277:
! 278: # At one point this particular corrupt database was causing a buffer
! 279: # overread. Which caused a crash in a run of all.test once.
! 280: #
! 281: do_test corruptC-2.15 {
! 282: db close
! 283: forcecopy test.bu test.db
! 284: hexio_write test.db 986 b9
! 285: sqlite3 db test.db
! 286: catchsql {SELECT count(*) FROM sqlite_master;}
! 287: } {1 {malformed database schema (t1i1) - no such table: main.t1}}
! 288:
! 289: #
! 290: # Now test for a series of quasi-random seeds.
! 291: # We loop over the entire file size and touch
! 292: # each byte at least once.
! 293: for {set tn 0} {$tn<$fsize} {incr tn 1} {
! 294:
! 295: # setup for test
! 296: db close
! 297: forcecopy test.bu test.db
! 298: sqlite3 db test.db
! 299:
! 300: # Seek to a random location in the file, and write a random single byte
! 301: # value. Then do various operations on the file to make sure that
! 302: # the database engine can handle the corruption gracefully.
! 303: #
! 304: set last 0
! 305: for {set i 1} {$i<=512 && !$last} {incr i 1} {
! 306:
! 307: db close
! 308: if {$i==1} {
! 309: # on the first corrupt value, use location $tn
! 310: # this ensures that we touch each location in the
! 311: # file at least once.
! 312: set roffset $tn
! 313: } else {
! 314: # insert random byte at random location
! 315: set roffset [random $fsize]
! 316: }
! 317: set rbyte [format %02x [random 255]]
! 318:
! 319: # You can uncomment the following to have it trace
! 320: # exactly how it's corrupting the file. This is
! 321: # useful for generating the "seed specific" tests
! 322: # above.
! 323: # set rline "$roffset $rbyte"
! 324: # puts stdout $rline
! 325:
! 326: hexio_write test.db $roffset $rbyte
! 327: sqlite3 db test.db
! 328:
! 329: # do a few random operations to make sure that if
! 330: # they error, they error gracefully instead of crashing.
! 331: do_test corruptC-3.$tn.($qseed).$i.1 {
! 332: catchsql {SELECT count(*) FROM sqlite_master}
! 333: set x {}
! 334: } {}
! 335: do_test corruptC-3.$tn.($qseed).$i.2 {
! 336: catchsql {SELECT count(*) FROM t1}
! 337: set x {}
! 338: } {}
! 339: do_test corruptC-3.$tn.($qseed).$i.3 {
! 340: catchsql {SELECT count(*) FROM t1 WHERE x>13}
! 341: set x {}
! 342: } {}
! 343: do_test corruptC-3.$tn.($qseed).$i.4 {
! 344: catchsql {SELECT count(*) FROM t2}
! 345: set x {}
! 346: } {}
! 347: do_test corruptC-3.$tn.($qseed).$i.5 {
! 348: catchsql {SELECT count(*) FROM t2 WHERE x<13}
! 349: set x {}
! 350: } {}
! 351: do_test corruptC-3.$tn.($qseed).$i.6 {
! 352: catchsql {BEGIN; UPDATE t1 SET y=1; ROLLBACK;}
! 353: set x {}
! 354: } {}
! 355: do_test corruptC-3.$tn.($qseed).$i.7 {
! 356: catchsql {BEGIN; UPDATE t2 SET y='abcdef-uvwxyz'; ROLLBACK;}
! 357: set x {}
! 358: } {}
! 359: do_test corruptC-3.$tn.($qseed).$i.8 {
! 360: catchsql {BEGIN; DELETE FROM t1 WHERE x>13; ROLLBACK;}
! 361: set x {}
! 362: } {}
! 363: do_test corruptC-3.$tn.($qseed).$i.9 {
! 364: catchsql {BEGIN; DELETE FROM t2 WHERE x<13; ROLLBACK;}
! 365: set x {}
! 366: } {}
! 367: do_test corruptC-3.$tn.($qseed).$i.10 {
! 368: catchsql {BEGIN; CREATE TABLE t3 AS SELECT x,3 as y FROM t2 WHERE rowid%5!=0; ROLLBACK;}
! 369: set x {}
! 370: } {}
! 371:
! 372: # check the integrity of the database.
! 373: # once the corruption is detected, we can stop.
! 374: ifcapable {integrityck} {
! 375: set res [ catchsql {PRAGMA integrity_check} ]
! 376: set ans [lindex $res 1]
! 377: if { [ string compare $ans "ok" ] != 0 } {
! 378: set last -1
! 379: }
! 380: }
! 381: # if we are not capable of doing an integrity check,
! 382: # stop after corrupting 5 bytes.
! 383: ifcapable {!integrityck} {
! 384: if { $i > 5 } {
! 385: set last -1
! 386: }
! 387: }
! 388:
! 389: # Check that no page references were leaked.
! 390: # TBD: need to figure out why this doesn't work
! 391: # work with ROLLBACKs...
! 392: if {0} {
! 393: do_test corruptC-3.$tn.($qseed).$i.11 {
! 394: set bt [btree_from_db db]
! 395: db_enter db
! 396: array set stats [btree_pager_stats $bt]
! 397: db_leave db
! 398: set stats(ref)
! 399: } {0}
! 400: }
! 401: }
! 402: # end for i
! 403:
! 404: }
! 405: # end for tn
! 406:
! 407: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to corruptC.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