Annotation of embedaddon/sqlite3/test/corrupt2.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.
! 15: #
! 16: # $Id: corrupt2.test,v 1.20 2009/04/06 17:50:03 danielk1977 Exp $
! 17:
! 18: set testdir [file dirname $argv0]
! 19: source $testdir/tester.tcl
! 20:
! 21: # Do not use a codec for tests in this file, as the database file is
! 22: # manipulated directly using tcl scripts (using the [hexio_write] command).
! 23: #
! 24: do_not_use_codec
! 25:
! 26: set presql ""
! 27: catch { set presql "$::G(perm:presql);" }
! 28: unset -nocomplain ::G(perm:presql)
! 29:
! 30: # The following tests - corrupt2-1.* - create some databases corrupted in
! 31: # specific ways and ensure that SQLite detects them as corrupt.
! 32: #
! 33: do_test corrupt2-1.1 {
! 34: execsql {
! 35: PRAGMA auto_vacuum=0;
! 36: PRAGMA page_size=1024;
! 37: CREATE TABLE abc(a, b, c);
! 38: }
! 39: } {}
! 40:
! 41: do_test corrupt2-1.2 {
! 42:
! 43: # Corrupt the 16 byte magic string at the start of the file
! 44: forcedelete corrupt.db
! 45: forcedelete corrupt.db-journal
! 46: forcecopy test.db corrupt.db
! 47: set f [open corrupt.db RDWR]
! 48: seek $f 8 start
! 49: puts $f blah
! 50: close $f
! 51:
! 52: sqlite3 db2 corrupt.db
! 53: catchsql "
! 54: $::presql
! 55: SELECT * FROM sqlite_master;
! 56: " db2
! 57: } {1 {file is encrypted or is not a database}}
! 58:
! 59: do_test corrupt2-1.3 {
! 60: db2 close
! 61:
! 62: # Corrupt the page-size (bytes 16 and 17 of page 1).
! 63: forcedelete corrupt.db
! 64: forcedelete corrupt.db-journal
! 65: forcecopy test.db corrupt.db
! 66: set f [open corrupt.db RDWR]
! 67: fconfigure $f -encoding binary
! 68: seek $f 16 start
! 69: puts -nonewline $f "\x00\xFF"
! 70: close $f
! 71:
! 72: sqlite3 db2 corrupt.db
! 73: catchsql "
! 74: $::presql
! 75: SELECT * FROM sqlite_master;
! 76: " db2
! 77: } {1 {file is encrypted or is not a database}}
! 78:
! 79: do_test corrupt2-1.4 {
! 80: db2 close
! 81:
! 82: # Corrupt the free-block list on page 1.
! 83: forcedelete corrupt.db
! 84: forcedelete corrupt.db-journal
! 85: forcecopy test.db corrupt.db
! 86: set f [open corrupt.db RDWR]
! 87: fconfigure $f -encoding binary
! 88: seek $f 101 start
! 89: puts -nonewline $f "\xFF\xFF"
! 90: close $f
! 91:
! 92: sqlite3 db2 corrupt.db
! 93: catchsql "
! 94: $::presql
! 95: SELECT * FROM sqlite_master;
! 96: " db2
! 97: } {1 {database disk image is malformed}}
! 98:
! 99: do_test corrupt2-1.5 {
! 100: db2 close
! 101:
! 102: # Corrupt the free-block list on page 1.
! 103: forcedelete corrupt.db
! 104: forcedelete corrupt.db-journal
! 105: forcecopy test.db corrupt.db
! 106: set f [open corrupt.db RDWR]
! 107: fconfigure $f -encoding binary
! 108: seek $f 101 start
! 109: puts -nonewline $f "\x00\xC8"
! 110: seek $f 200 start
! 111: puts -nonewline $f "\x00\x00"
! 112: puts -nonewline $f "\x10\x00"
! 113: close $f
! 114:
! 115: sqlite3 db2 corrupt.db
! 116: catchsql "
! 117: $::presql
! 118: SELECT * FROM sqlite_master;
! 119: " db2
! 120: } {1 {database disk image is malformed}}
! 121: db2 close
! 122:
! 123: # Corrupt a database by having 2 indices of the same name:
! 124: do_test corrupt2-2.1 {
! 125:
! 126: forcedelete corrupt.db
! 127: forcedelete corrupt.db-journal
! 128: forcecopy test.db corrupt.db
! 129:
! 130: sqlite3 db2 corrupt.db
! 131: execsql "
! 132: $::presql
! 133: CREATE INDEX a1 ON abc(a);
! 134: CREATE INDEX a2 ON abc(b);
! 135: PRAGMA writable_schema = 1;
! 136: UPDATE sqlite_master
! 137: SET name = 'a3', sql = 'CREATE INDEX a3' || substr(sql, 16, 10000)
! 138: WHERE type = 'index';
! 139: PRAGMA writable_schema = 0;
! 140: " db2
! 141:
! 142: db2 close
! 143: sqlite3 db2 corrupt.db
! 144: catchsql "
! 145: $::presql
! 146: SELECT * FROM sqlite_master;
! 147: " db2
! 148: } {1 {malformed database schema (a3) - index a3 already exists}}
! 149:
! 150: db2 close
! 151:
! 152: do_test corrupt2-3.1 {
! 153: forcedelete corrupt.db
! 154: forcedelete corrupt.db-journal
! 155: sqlite3 db2 corrupt.db
! 156:
! 157: execsql "
! 158: $::presql
! 159: PRAGMA auto_vacuum = 1;
! 160: PRAGMA page_size = 1024;
! 161: CREATE TABLE t1(a, b, c);
! 162: CREATE TABLE t2(a, b, c);
! 163: INSERT INTO t2 VALUES(randomblob(100), randomblob(100), randomblob(100));
! 164: INSERT INTO t2 SELECT * FROM t2;
! 165: INSERT INTO t2 SELECT * FROM t2;
! 166: INSERT INTO t2 SELECT * FROM t2;
! 167: INSERT INTO t2 SELECT * FROM t2;
! 168: " db2
! 169:
! 170: db2 close
! 171:
! 172: # On the root page of table t2 (page 4), set one of the child page-numbers
! 173: # to 0. This corruption will be detected when SQLite attempts to update
! 174: # the pointer-map after moving the content of page 4 to page 3 as part
! 175: # of the DROP TABLE operation below.
! 176: #
! 177: set fd [open corrupt.db r+]
! 178: fconfigure $fd -encoding binary -translation binary
! 179: seek $fd [expr 1024*3 + 12]
! 180: set zCelloffset [read $fd 2]
! 181: binary scan $zCelloffset S iCelloffset
! 182: seek $fd [expr 1024*3 + $iCelloffset]
! 183: puts -nonewline $fd "\00\00\00\00"
! 184: close $fd
! 185:
! 186: sqlite3 db2 corrupt.db
! 187: catchsql "
! 188: $::presql
! 189: DROP TABLE t1;
! 190: " db2
! 191: } {1 {database disk image is malformed}}
! 192:
! 193: do_test corrupt2-4.1 {
! 194: catchsql {
! 195: SELECT * FROM t2;
! 196: } db2
! 197: } {1 {database disk image is malformed}}
! 198:
! 199: db2 close
! 200:
! 201: unset -nocomplain result
! 202: do_test corrupt2-5.1 {
! 203: forcedelete corrupt.db
! 204: forcedelete corrupt.db-journal
! 205: sqlite3 db2 corrupt.db
! 206:
! 207: execsql "
! 208: $::presql
! 209: PRAGMA auto_vacuum = 0;
! 210: PRAGMA page_size = 1024;
! 211: CREATE TABLE t1(a, b, c);
! 212: CREATE TABLE t2(a, b, c);
! 213: INSERT INTO t2 VALUES(randomblob(100), randomblob(100), randomblob(100));
! 214: INSERT INTO t2 SELECT * FROM t2;
! 215: INSERT INTO t2 SELECT * FROM t2;
! 216: INSERT INTO t2 SELECT * FROM t2;
! 217: INSERT INTO t2 SELECT * FROM t2;
! 218: INSERT INTO t1 SELECT * FROM t2;
! 219: " db2
! 220:
! 221: db2 close
! 222:
! 223: # This block links a page from table t2 into the t1 table structure.
! 224: #
! 225: set fd [open corrupt.db r+]
! 226: fconfigure $fd -encoding binary -translation binary
! 227: seek $fd [expr 1024 + 12]
! 228: set zCelloffset [read $fd 2]
! 229: binary scan $zCelloffset S iCelloffset
! 230: seek $fd [expr 1024 + $iCelloffset]
! 231: set zChildPage [read $fd 4]
! 232: seek $fd [expr 2*1024 + 12]
! 233: set zCelloffset [read $fd 2]
! 234: binary scan $zCelloffset S iCelloffset
! 235: seek $fd [expr 2*1024 + $iCelloffset]
! 236: puts -nonewline $fd $zChildPage
! 237: close $fd
! 238:
! 239: sqlite3 db2 corrupt.db
! 240: db2 eval $::presql
! 241: db2 eval {SELECT rowid FROM t1} {
! 242: set result [db2 eval {pragma integrity_check}]
! 243: break
! 244: }
! 245: set result
! 246: } {{*** in database main ***
! 247: On tree page 2 cell 0: 2nd reference to page 10
! 248: On tree page 2 cell 1: Child page depth differs
! 249: Page 4 is never used}}
! 250:
! 251: db2 close
! 252:
! 253: proc corruption_test {args} {
! 254: set A(-corrupt) {}
! 255: set A(-sqlprep) {}
! 256: set A(-tclprep) {}
! 257: array set A $args
! 258:
! 259: catch {db close}
! 260: forcedelete corrupt.db
! 261: forcedelete corrupt.db-journal
! 262:
! 263: sqlite3 db corrupt.db
! 264: db eval $::presql
! 265: eval $A(-tclprep)
! 266: db eval $A(-sqlprep)
! 267: db close
! 268:
! 269: eval $A(-corrupt)
! 270:
! 271: sqlite3 db corrupt.db
! 272: eval $A(-test)
! 273: }
! 274:
! 275: ifcapable autovacuum {
! 276: # The tests within this block - corrupt2-6.* - aim to test corruption
! 277: # detection within an incremental-vacuum. When an incremental-vacuum
! 278: # step is executed, the last non-free page of the database file is
! 279: # moved into a free space in the body of the file. After doing so,
! 280: # the page reference in the parent page must be updated to refer
! 281: # to the new location. These tests test the outcome of corrupting
! 282: # that page reference before performing the incremental vacuum.
! 283: #
! 284:
! 285: # The last page in the database page is the second page
! 286: # in an overflow chain.
! 287: #
! 288: corruption_test -sqlprep {
! 289: PRAGMA auto_vacuum = incremental;
! 290: PRAGMA page_size = 1024;
! 291: CREATE TABLE t1(a, b);
! 292: INSERT INTO t1 VALUES(1, randomblob(2500));
! 293: INSERT INTO t1 VALUES(2, randomblob(2500));
! 294: DELETE FROM t1 WHERE a = 1;
! 295: } -corrupt {
! 296: hexio_write corrupt.db [expr 1024*5] 00000008
! 297: } -test {
! 298: do_test corrupt2-6.1 {
! 299: catchsql " $::presql pragma incremental_vacuum = 1 "
! 300: } {1 {database disk image is malformed}}
! 301: }
! 302:
! 303: # The last page in the database page is a non-root b-tree page.
! 304: #
! 305: corruption_test -sqlprep {
! 306: PRAGMA auto_vacuum = incremental;
! 307: PRAGMA page_size = 1024;
! 308: CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
! 309: INSERT INTO t1 VALUES(1, randomblob(2500));
! 310: INSERT INTO t1 VALUES(2, randomblob(50));
! 311: INSERT INTO t1 SELECT NULL, randomblob(50) FROM t1;
! 312: INSERT INTO t1 SELECT NULL, randomblob(50) FROM t1;
! 313: INSERT INTO t1 SELECT NULL, randomblob(50) FROM t1;
! 314: INSERT INTO t1 SELECT NULL, randomblob(50) FROM t1;
! 315: DELETE FROM t1 WHERE a = 1;
! 316: } -corrupt {
! 317: hexio_write corrupt.db [expr 1024*2 + 8] 00000009
! 318: } -test {
! 319: do_test corrupt2-6.2 {
! 320: catchsql " $::presql pragma incremental_vacuum = 1 "
! 321: } {1 {database disk image is malformed}}
! 322: }
! 323:
! 324: # Set up a pointer-map entry so that the last page of the database
! 325: # file appears to be a b-tree root page. This should be detected
! 326: # as corruption.
! 327: #
! 328: corruption_test -sqlprep {
! 329: PRAGMA auto_vacuum = incremental;
! 330: PRAGMA page_size = 1024;
! 331: CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
! 332: INSERT INTO t1 VALUES(1, randomblob(2500));
! 333: INSERT INTO t1 VALUES(2, randomblob(2500));
! 334: INSERT INTO t1 VALUES(3, randomblob(2500));
! 335: DELETE FROM t1 WHERE a = 1;
! 336: } -corrupt {
! 337: set nPage [expr [file size corrupt.db] / 1024]
! 338: hexio_write corrupt.db [expr 1024 + ($nPage-3)*5] 010000000
! 339: } -test {
! 340: do_test corrupt2-6.3 {
! 341: catchsql " $::presql pragma incremental_vacuum = 1 "
! 342: } {1 {database disk image is malformed}}
! 343: }
! 344:
! 345: corruption_test -sqlprep {
! 346: PRAGMA auto_vacuum = 1;
! 347: PRAGMA page_size = 1024;
! 348: CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
! 349: INSERT INTO t1 VALUES(1, randomblob(2500));
! 350: DELETE FROM t1 WHERE a = 1;
! 351: } -corrupt {
! 352: set nAppend [expr 1024*207 - [file size corrupt.db]]
! 353: set fd [open corrupt.db r+]
! 354: seek $fd 0 end
! 355: puts -nonewline $fd [string repeat x $nAppend]
! 356: close $fd
! 357: hexio_write corrupt.db 28 00000000
! 358: } -test {
! 359: do_test corrupt2-6.4 {
! 360: catchsql "
! 361: $::presql
! 362: BEGIN EXCLUSIVE;
! 363: COMMIT;
! 364: "
! 365: } {1 {database disk image is malformed}}
! 366: }
! 367: }
! 368:
! 369:
! 370: set sqlprep {
! 371: PRAGMA auto_vacuum = 0;
! 372: PRAGMA page_size = 1024;
! 373: CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
! 374: CREATE INDEX i1 ON t1(b);
! 375: INSERT INTO t1 VALUES(1, randomblob(50));
! 376: INSERT INTO t1 SELECT NULL, randomblob(50) FROM t1;
! 377: INSERT INTO t1 SELECT NULL, randomblob(50) FROM t1;
! 378: INSERT INTO t1 SELECT NULL, randomblob(50) FROM t1;
! 379: INSERT INTO t1 SELECT NULL, randomblob(50) FROM t1;
! 380: INSERT INTO t1 SELECT NULL, randomblob(50) FROM t1;
! 381: INSERT INTO t1 SELECT NULL, randomblob(50) FROM t1;
! 382: }
! 383:
! 384: corruption_test -sqlprep $sqlprep -corrupt {
! 385: # Set the page-flags of one of the leaf pages of the index B-Tree to
! 386: # 0x0D (interpreted by SQLite as "leaf page of a table B-Tree").
! 387: #
! 388: set fd [open corrupt.db r+]
! 389: fconfigure $fd -translation binary -encoding binary
! 390: seek $fd [expr 1024*2 + 8]
! 391: set zRightChild [read $fd 4]
! 392: binary scan $zRightChild I iRightChild
! 393: seek $fd [expr 1024*($iRightChild-1)]
! 394: puts -nonewline $fd "\x0D"
! 395: close $fd
! 396: } -test {
! 397: do_test corrupt2-7.1 {
! 398: catchsql " $::presql SELECT b FROM t1 ORDER BY b ASC "
! 399: } {1 {database disk image is malformed}}
! 400: }
! 401:
! 402: corruption_test -sqlprep $sqlprep -corrupt {
! 403: # Mess up the page-header of one of the leaf pages of the index B-Tree.
! 404: # The corruption is detected as part of an OP_Prev opcode.
! 405: #
! 406: set fd [open corrupt.db r+]
! 407: fconfigure $fd -translation binary -encoding binary
! 408: seek $fd [expr 1024*2 + 12]
! 409: set zCellOffset [read $fd 2]
! 410: binary scan $zCellOffset S iCellOffset
! 411: seek $fd [expr 1024*2 + $iCellOffset]
! 412: set zChild [read $fd 4]
! 413: binary scan $zChild I iChild
! 414: seek $fd [expr 1024*($iChild-1)+3]
! 415: puts -nonewline $fd "\xFFFF"
! 416: close $fd
! 417: } -test {
! 418: do_test corrupt2-7.1 {
! 419: catchsql " $::presql SELECT b FROM t1 ORDER BY b DESC "
! 420: } {1 {database disk image is malformed}}
! 421: }
! 422:
! 423: corruption_test -sqlprep $sqlprep -corrupt {
! 424: # Set the page-flags of one of the leaf pages of the table B-Tree to
! 425: # 0x0A (interpreted by SQLite as "leaf page of an index B-Tree").
! 426: #
! 427: set fd [open corrupt.db r+]
! 428: fconfigure $fd -translation binary -encoding binary
! 429: seek $fd [expr 1024*1 + 8]
! 430: set zRightChild [read $fd 4]
! 431: binary scan $zRightChild I iRightChild
! 432: seek $fd [expr 1024*($iRightChild-1)]
! 433: puts -nonewline $fd "\x0A"
! 434: close $fd
! 435: } -test {
! 436: do_test corrupt2-8.1 {
! 437: catchsql " $::presql SELECT * FROM t1 WHERE rowid=1000 "
! 438: } {1 {database disk image is malformed}}
! 439: }
! 440:
! 441: corruption_test -sqlprep {
! 442: CREATE TABLE t1(a, b, c); CREATE TABLE t8(a, b, c); CREATE TABLE tE(a, b, c);
! 443: CREATE TABLE t2(a, b, c); CREATE TABLE t9(a, b, c); CREATE TABLE tF(a, b, c);
! 444: CREATE TABLE t3(a, b, c); CREATE TABLE tA(a, b, c); CREATE TABLE tG(a, b, c);
! 445: CREATE TABLE t4(a, b, c); CREATE TABLE tB(a, b, c); CREATE TABLE tH(a, b, c);
! 446: CREATE TABLE t5(a, b, c); CREATE TABLE tC(a, b, c); CREATE TABLE tI(a, b, c);
! 447: CREATE TABLE t6(a, b, c); CREATE TABLE tD(a, b, c); CREATE TABLE tJ(a, b, c);
! 448: CREATE TABLE x1(a, b, c); CREATE TABLE x8(a, b, c); CREATE TABLE xE(a, b, c);
! 449: CREATE TABLE x2(a, b, c); CREATE TABLE x9(a, b, c); CREATE TABLE xF(a, b, c);
! 450: CREATE TABLE x3(a, b, c); CREATE TABLE xA(a, b, c); CREATE TABLE xG(a, b, c);
! 451: CREATE TABLE x4(a, b, c); CREATE TABLE xB(a, b, c); CREATE TABLE xH(a, b, c);
! 452: CREATE TABLE x5(a, b, c); CREATE TABLE xC(a, b, c); CREATE TABLE xI(a, b, c);
! 453: CREATE TABLE x6(a, b, c); CREATE TABLE xD(a, b, c); CREATE TABLE xJ(a, b, c);
! 454: } -corrupt {
! 455: set fd [open corrupt.db r+]
! 456: fconfigure $fd -translation binary -encoding binary
! 457: seek $fd 108
! 458: set zRightChild [read $fd 4]
! 459: binary scan $zRightChild I iRightChild
! 460: seek $fd [expr 1024*($iRightChild-1)+3]
! 461: puts -nonewline $fd "\x00\x00"
! 462: close $fd
! 463: } -test {
! 464: do_test corrupt2-9.1 {
! 465: catchsql " $::presql SELECT sql FROM sqlite_master "
! 466: } {1 {database disk image is malformed}}
! 467: }
! 468:
! 469: corruption_test -sqlprep {
! 470: CREATE TABLE t1(a, b, c);
! 471: CREATE TABLE t2(a, b, c);
! 472: PRAGMA writable_schema = 1;
! 473: UPDATE sqlite_master SET rootpage = NULL WHERE name = 't2';
! 474: } -test {
! 475: do_test corrupt2-10.1 {
! 476: catchsql " $::presql SELECT * FROM t2 "
! 477: } {1 {malformed database schema (t2)}}
! 478: do_test corrupt2-10.2 {
! 479: sqlite3_errcode db
! 480: } {SQLITE_CORRUPT}
! 481: }
! 482:
! 483: corruption_test -sqlprep {
! 484: PRAGMA auto_vacuum = incremental;
! 485: CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
! 486: CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
! 487: INSERT INTO t1 VALUES(1, randstr(100,100));
! 488: INSERT INTO t1 SELECT NULL, randstr(100,100) FROM t1;
! 489: INSERT INTO t1 SELECT NULL, randstr(100,100) FROM t1;
! 490: INSERT INTO t1 SELECT NULL, randstr(100,100) FROM t1;
! 491: INSERT INTO t1 SELECT NULL, randstr(100,100) FROM t1;
! 492: INSERT INTO t1 SELECT NULL, randstr(100,100) FROM t1;
! 493: INSERT INTO t2 SELECT * FROM t1;
! 494: DELETE FROM t1;
! 495: } -corrupt {
! 496: set offset [expr [file size corrupt.db] - 1024]
! 497: hexio_write corrupt.db $offset FF
! 498: hexio_write corrupt.db 24 12345678
! 499: } -test {
! 500: do_test corrupt2-11.1 {
! 501: catchsql " $::presql PRAGMA incremental_vacuum "
! 502: } {1 {database disk image is malformed}}
! 503: }
! 504: corruption_test -sqlprep {
! 505: PRAGMA auto_vacuum = incremental;
! 506: CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
! 507: CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
! 508: INSERT INTO t1 VALUES(1, randstr(100,100));
! 509: INSERT INTO t1 SELECT NULL, randstr(100,100) FROM t1;
! 510: INSERT INTO t1 SELECT NULL, randstr(100,100) FROM t1;
! 511: INSERT INTO t1 SELECT NULL, randstr(100,100) FROM t1;
! 512: INSERT INTO t1 SELECT NULL, randstr(100,100) FROM t1;
! 513: INSERT INTO t1 SELECT NULL, randstr(100,100) FROM t1;
! 514: INSERT INTO t2 SELECT * FROM t1;
! 515: DELETE FROM t1;
! 516: } -corrupt {
! 517: set pgno [expr [file size corrupt.db] / 1024]
! 518: hexio_write corrupt.db [expr 1024+5*($pgno-3)] 03
! 519: hexio_write corrupt.db 24 12345678
! 520: } -test {
! 521: do_test corrupt2-12.1 {
! 522: catchsql " $::presql PRAGMA incremental_vacuum "
! 523: } {1 {database disk image is malformed}}
! 524: }
! 525:
! 526: ifcapable autovacuum {
! 527: # It is not possible for the last page in a database file to be the
! 528: # pending-byte page (AKA the locking page). This test verifies that if
! 529: # an attempt is made to commit a transaction to such an auto-vacuum
! 530: # database SQLITE_CORRUPT is returned.
! 531: #
! 532: corruption_test -tclprep {
! 533: db eval {
! 534: PRAGMA auto_vacuum = full;
! 535: PRAGMA page_size = 1024;
! 536: CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
! 537: INSERT INTO t1 VALUES(NULL, randstr(50,50));
! 538: }
! 539: for {set ii 0} {$ii < 10} {incr ii} {
! 540: db eval " $::presql INSERT INTO t1 SELECT NULL, randstr(50,50) FROM t1 "
! 541: }
! 542: } -corrupt {
! 543: do_test corrupt2-13.1 {
! 544: file size corrupt.db
! 545: } $::sqlite_pending_byte
! 546: hexio_write corrupt.db [expr $::sqlite_pending_byte+1023] 00
! 547: hexio_write corrupt.db 28 00000000
! 548: } -test {
! 549: do_test corrupt2-13.2 {
! 550: file size corrupt.db
! 551: } [expr $::sqlite_pending_byte + 1024]
! 552: do_test corrupt2-13.3 {
! 553: catchsql { DELETE FROM t1 WHERE rowid < 30; }
! 554: } {1 {database disk image is malformed}}
! 555: }
! 556: }
! 557:
! 558: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to corrupt2.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