wasCSharpSQLite – Blame information for rev

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 # 2010 September 1
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/malloc_common.tcl
16  
17 db close
18  
19 do_test quota-1.1 { sqlite3_quota_initialize nosuchvfs 1 } {SQLITE_ERROR}
20 do_test quota-1.2 { sqlite3_quota_initialize "" 1 } {SQLITE_OK}
21 do_test quota-1.3 { sqlite3_quota_initialize "" 1 } {SQLITE_MISUSE}
22 do_test quota-1.4 { sqlite3_quota_shutdown } {SQLITE_OK}
23  
24 do_test quota-1.5 { sqlite3_quota_initialize "" 0 } {SQLITE_OK}
25 do_test quota-1.6 { sqlite3_quota_shutdown } {SQLITE_OK}
26 do_test quota-1.7 { sqlite3_quota_initialize "" 1 } {SQLITE_OK}
27 do_test quota-1.8 { sqlite3_quota_shutdown } {SQLITE_OK}
28  
29  
30 #-------------------------------------------------------------------------
31 # Some simple warm-body tests with a single database file in rollback
32 # mode:
33 #
34 # quota-2.1.*: Test that SQLITE_FULL is returned if the database would
35 # exceed the configured quota.
36 #
37 # quota-2.2.*: Test that SQLITE_FULL is not returned and the database
38 # grows if the callback extends the quota when the database
39 # attempts to grow beyond the configured quota.
40 #
41 # quota-2.3.*: Open and close a db that is not part of any quota group. At
42 # one point this was causing mutex refs to be leaked.
43 #
44 # quota-2.4.*: Try to shutdown the quota system before closing the db
45 # file. Check that this fails and the quota system still works
46 # afterwards. Then close the database and successfully shut
47 # down the quota system.
48 #
49 sqlite3_quota_initialize "" 1
50  
51 proc quota_check {filename limitvar size} {
52 upvar $limitvar limit
53  
54 lappend ::quota [set limit] $size
55 if {[info exists ::quota_request_ok]} { set limit $size }
56 }
57  
58 do_test quota-2.1.1 {
59 sqlite3_quota_set *test.db 4096 quota_check
60 } {SQLITE_OK}
61 do_test quota-2.1.2 {
62 sqlite3 db test.db
63 execsql {
64 PRAGMA page_size=1024;
65 PRAGMA auto_vacuum=OFF;
66 PRAGMA journal_mode=DELETE;
67 }
68 set ::quota [list]
69 execsql {
70 CREATE TABLE t1(a, b);
71 INSERT INTO t1 VALUES(1, randomblob(1100));
72 INSERT INTO t1 VALUES(2, randomblob(1100));
73 }
74 set ::quota
75 } {}
76 do_test quota-2.1.3 { file size test.db } {4096}
77 do_test quota-2.1.4 {
78 catchsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
79 } {1 {database or disk is full}}
80 do_test quota-2.1.5 { set ::quota } {4096 5120}
81  
82 set ::quota_request_ok 1
83 set ::quota [list]
84 do_test quota-2.2.1 {
85 execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
86 } {}
87 do_test quota-2.2.2 { set ::quota } {4096 5120}
88 do_test quota-2.2.3 { file size test.db } {5120}
89 unset ::quota_request_ok
90  
91 do_test quota-2.3.1 {
92 sqlite3 db2 bak.db
93 db2 close
94 } {}
95  
96 do_test quota-2.4.1 {
97 sqlite3_quota_shutdown
98 } {SQLITE_MISUSE}
99 set ::quota [list]
100 do_test quota-2.4.2 {
101 catchsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
102 } {1 {database or disk is full}}
103 do_test quota-2.4.3 { set ::quota } {5120 6144}
104 do_test quota-2.4.4 { file size test.db } {5120}
105 do_test quota-2.4.99 {
106 db close
107 sqlite3_quota_shutdown
108 } {SQLITE_OK}
109  
110 #-------------------------------------------------------------------------
111 # Try some tests with more than one connection to a database file. Still
112 # in rollback mode.
113 #
114 # quota-3.1.*: Two connections to a single database file.
115 #
116 # quota-3.2.*: Two connections to each of several database files (that
117 # are in the same quota group).
118 #
119 proc quota_check {filename limitvar size} {
120 upvar $limitvar limit
121 lappend ::quota [set limit] $size
122 if {[info exists ::quota_request_ok]} { set limit $size }
123 }
124  
125 do_test quota-3.1.1 {
126 file delete -force test.db
127 sqlite3_quota_initialize "" 1
128 sqlite3_quota_set *test.db 4096 quota_check
129 } {SQLITE_OK}
130 do_test quota-3.1.2 {
131 sqlite3 db test.db
132 execsql {
133 PRAGMA page_size = 1024;
134 PRAGMA journal_mode = delete;
135 PRAGMA auto_vacuum = off;
136 CREATE TABLE t1(a PRIMARY KEY, b);
137 INSERT INTO t1 VALUES(1, 'one');
138 }
139 file size test.db
140 } {3072}
141 do_test quota-3.1.3 {
142 sqlite3 db2 test.db
143 set ::quota [list]
144 execsql { CREATE TABLE t2(a, b) } db2
145 set ::quota
146 } {}
147 do_test quota-3.1.4 {
148 catchsql { CREATE TABLE t3(a, b) }
149 } {1 {database or disk is full}}
150 do_test quota-3.1.5 {
151 set ::quota_request_ok 1
152 execsql { CREATE TABLE t3(a, b) }
153 } {}
154 do_test quota-3.1.6 {
155 db close
156 db2 close
157 sqlite3_quota_set *test.db 0 {}
158 } {SQLITE_OK}
159  
160 do_test quota-3.2.1 {
161 file delete force test.db test2.db
162  
163 sqlite3_quota_set * 4096 {}
164 sqlite3 db1a test.db
165 sqlite3 db2a test2.db
166  
167 foreach db {db1a db2a} {
168 execsql {
169 PRAGMA page_size = 1024;
170 PRAGMA journal_mode = delete;
171 PRAGMA auto_vacuum = off;
172 CREATE TABLE t1(a, b);
173 } $db
174 }
175  
176 sqlite3 db1b test.db
177 sqlite3 db2b test2.db
178  
179 list [file size test.db] [file size test2.db]
180 } {2048 2048}
181  
182 catch { unset ::quota_request_ok }
183  
184 do_test quota-3.2.2 { execsql { INSERT INTO t1 VALUES('x', 'y') } db1a } {}
185 do_test quota-3.2.3 { execsql { INSERT INTO t1 VALUES('v', 'w') } db1b } {}
186 do_test quota-3.2.4 { execsql { INSERT INTO t1 VALUES('t', 'u') } db2a } {}
187 do_test quota-3.2.5 { execsql { INSERT INTO t1 VALUES('r', 's') } db2b } {}
188  
189 do_test quota-3.2.6 {
190 catchsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a
191 } {1 {database or disk is full}}
192 do_test quota-3.2.7 {
193 catchsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b
194 } {1 {database or disk is full}}
195 do_test quota-3.2.8 {
196 catchsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a
197 } {1 {database or disk is full}}
198 do_test quota-3.2.9 {
199 catchsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b
200 } {1 {database or disk is full}}
201  
202 set ::quota [list]
203 proc quota_callback {file limitvar size} {
204 upvar $limitvar limit
205 if {$::tcl_platform(platform)=="windows"} {
206 set file [ lindex [string map {\\ \/} $file] 0 ]
207 }
208 lappend ::quota $file $size
209 set limit 0
210 }
211 sqlite3_quota_set * 4096 quota_callback
212 do_test quota-3.3.1 {
213 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a
214 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b
215 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a
216 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b
217 set ::quota
218 } [list [file join [pwd] test.db] 5120]
219  
220 do_test quota-3.2.X {
221 foreach db {db1a db2a db2b db1b} { catch { $db close } }
222 sqlite3_quota_set * 0 {}
223 } {SQLITE_OK}
224  
225 #-------------------------------------------------------------------------
226 # Quotas are deleted when unused and when there limit is set to zero
227 #
228  
229 # Return a list of all currently defined quotas. Each quota is identified
230 # by its pattern.
231 proc quota_list {} {
232 set allq {}
233 foreach q [sqlite3_quota_dump] {
234 lappend allq [lindex $q 0]
235 }
236 return [lsort $allq]
237 }
238  
239 do_test quota-4.1.1 {
240 sqlite3_quota_set *test.db 0 {}
241 quota_list
242 } {}
243 do_test quota-4.1.2 {
244 sqlite3_quota_set *test.db 4096 {}
245 quota_list
246 } {*test.db}
247 do_test quota-4.1.3 {
248 sqlite3_quota_set *test2.db 0 {}
249 quota_list
250 } {*test.db}
251 do_test quota-4.1.4 {
252 sqlite3_quota_set *test2.db 100000 {}
253 quota_list
254 } {*test.db *test2.db}
255 do_test quota-4.1.5 {
256 sqlite3_quota_set *test.db 0 {}
257 quota_list
258 } {*test2.db}
259 do_test quota-4.1.6 {
260 file delete -force test2.db test2.db-journal test2.db-wal
261 sqlite3 db test2.db
262 db eval {CREATE TABLE t2(x); INSERT INTO t2 VALUES('tab-t2');}
263 quota_list
264 } {*test2.db}
265 do_test quota-4.1.7 {
266 catchsql {INSERT INTO t2 VALUES(zeroblob(200000))}
267 } {1 {database or disk is full}}
268 do_test quota-4.1.8 {
269 sqlite3 db2 test2.db
270 db2 eval {SELECT * FROM t2}
271 } {tab-t2}
272 do_test quota-4.1.9 {
273 sqlite3_quota_set *test2.db 0 {}
274 catchsql {INSERT INTO t2 VALUES(zeroblob(200000))}
275 } {0 {}}
276 do_test quota-4.1.10 {
277 quota_list
278 } {*test2.db}
279 do_test quota-4.1.11 {
280 db2 close
281 quota_list
282 } {*test2.db}
283 do_test quota-4.1.12 {
284 db close
285 quota_list
286 } {}
287  
288 do_test quota-4.2.1 {
289 sqlite3_quota_set A 1000 {}
290 sqlite3_quota_set B 1000 {}
291 sqlite3_quota_set C 1000 {}
292 sqlite3_quota_set D 1000 {}
293 quota_list
294 } {A B C D}
295 do_test quota-4.2.2 {
296 sqlite3_quota_set C 0 {}
297 sqlite3_quota_set B 0 {}
298 quota_list
299 } {A D}
300 do_test quota-4.2.3 {
301 sqlite3_quota_set A 0 {}
302 sqlite3_quota_set D 0 {}
303 quota_list
304 } {}
305 do_test quota-4.2.4 {
306 sqlite3_quota_set A 1000 {}
307 sqlite3_quota_set B 1000 {}
308 sqlite3_quota_set C 1000 {}
309 sqlite3_quota_set A 0 {}
310 sqlite3_quota_set B 0 {}
311 sqlite3_quota_set C 0 {}
312 quota_list
313 } {}
314 do_test quota-4.2.5 {
315 sqlite3_quota_set A 1000 {}
316 sqlite3_quota_set B 1000 {}
317 sqlite3_quota_set C 1000 {}
318 sqlite3_quota_set C 0 {}
319 sqlite3_quota_set B 0 {}
320 sqlite3_quota_set A 0 {}
321 quota_list
322 } {}
323  
324 do_test quota-4.3.1 {
325 sqlite3_quota_set A 1000 quota_callback
326 sqlite3 db A
327 sqlite3_quota_set A 0 quota_callback
328 db close
329 quota_list
330 } {}
331  
332 do_test quota-4.4.1 {
333 sqlite3_quota_set A 1000 quota_callback
334 sqlite3_quota_shutdown
335 } {SQLITE_OK}
336 do_test quota-4.4.2 {
337 quota_list
338 } {}
339  
340 #-------------------------------------------------------------------------
341 # The following tests test that the quota VFS handles malloc and IO
342 # errors.
343 #
344  
345 sqlite3_quota_initialize "" 1
346 sqlite3_quota_set *test.db 4096 {}
347  
348 do_faultsim_test quota-5.1 -prep {
349 catch {db close}
350 } -body {
351 sqlite3 db test2.db
352 }
353 do_faultsim_test quota-5.2 -prep {
354 catch {db close}
355 } -body {
356 sqlite3 db test.db
357 }
358  
359 catch { db close }
360 file delete -force test.db
361  
362 do_test quota-5.3.prep {
363 sqlite3 db test.db
364 execsql {
365 PRAGMA auto_vacuum = 1;
366 PRAGMA page_size = 1024;
367 CREATE TABLE t1(a, b);
368 INSERT INTO t1 VALUES(10, zeroblob(1200));
369 }
370 faultsim_save_and_close
371 } {}
372 do_faultsim_test quota-5.3 -prep {
373 faultsim_restore_and_reopen
374 } -body {
375 execsql { DELETE FROM t1 }
376 }
377  
378 do_test quota-5.4.1 {
379 catch { db close }
380 file delete -force test.db
381 file mkdir test.db
382 list [catch { sqlite3 db test.db } msg] $msg
383 } {1 {unable to open database file}}
384  
385 do_faultsim_test quota-5.5 -prep {
386 catch { sqlite3_quota_shutdown }
387 } -body {
388 sqlite3_quota_initialize "" 1
389 }
390  
391 do_faultsim_test quota-5.6 -prep {
392 catch { sqlite3_quota_shutdown }
393 sqlite3_quota_initialize "" 1
394 } -body {
395 sqlite3_quota_set * 4096 {}
396 }
397  
398 catch { sqlite3_quota_shutdown }
399 finish_test