wasCSharpSQLite – Blame information for rev 1

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