Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(23)

Side by Side Diff: third_party/sqlite/sqlite-src-3080704/test/corrupt2.test

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

Powered by Google App Engine
This is Rietveld 408576698