Annotation of embedaddon/sqlite3/test/quota.test, revision 1.1.1.1
1.1 misho 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: unset -nocomplain defaultVfs
18: set defaultVfs [file_control_vfsname db]
19: db close
20:
21: do_test quota-1.1 { sqlite3_quota_initialize nosuchvfs 1 } {SQLITE_ERROR}
22: do_test quota-1.2 { sqlite3_quota_initialize "" 1 } {SQLITE_OK}
23: do_test quota-1.3 { sqlite3_quota_initialize "" 1 } {SQLITE_MISUSE}
24: do_test quota-1.4 { sqlite3_quota_shutdown } {SQLITE_OK}
25:
26: do_test quota-1.5 { sqlite3_quota_initialize "" 0 } {SQLITE_OK}
27: do_test quota-1.6 { sqlite3_quota_shutdown } {SQLITE_OK}
28: do_test quota-1.7 { sqlite3_quota_initialize "" 1 } {SQLITE_OK}
29: do_test quota-1.8 { sqlite3_quota_shutdown } {SQLITE_OK}
30:
31:
32: #-------------------------------------------------------------------------
33: # Some simple warm-body tests with a single database file in rollback
34: # mode:
35: #
36: # quota-2.1.*: Test that SQLITE_FULL is returned if the database would
37: # exceed the configured quota.
38: #
39: # quota-2.2.*: Test that SQLITE_FULL is not returned and the database
40: # grows if the callback extends the quota when the database
41: # attempts to grow beyond the configured quota.
42: #
43: # quota-2.3.*: Open and close a db that is not part of any quota group. At
44: # one point this was causing mutex refs to be leaked.
45: #
46: # quota-2.4.*: Try to shutdown the quota system before closing the db
47: # file. Check that this fails and the quota system still works
48: # afterwards. Then close the database and successfully shut
49: # down the quota system.
50: #
51: sqlite3_quota_initialize "" 1
52:
53: unset -nocomplain quota_request_ok
54: proc quota_check {filename limitvar size} {
55: upvar $limitvar limit
56:
57: lappend ::quota [set limit] $size
58: if {[info exists ::quota_request_ok]} { set limit $size }
59: }
60:
61: do_test quota-2.1.1 {
62: sqlite3_quota_set *test.db 4096 quota_check
63: } {SQLITE_OK}
64: do_test quota-2.1.2 {
65: sqlite3 db test.db
66: execsql {
67: PRAGMA page_size=1024;
68: PRAGMA auto_vacuum=OFF;
69: PRAGMA journal_mode=DELETE;
70: }
71: set ::quota [list]
72: execsql {
73: CREATE TABLE t1(a, b);
74: INSERT INTO t1 VALUES(1, randomblob(1100));
75: INSERT INTO t1 VALUES(2, randomblob(1100));
76: }
77: set ::quota
78: } {}
79: do_test quota-2.1.2.1 {
80: file_control_vfsname db
81: } quota/$defaultVfs
82: do_test quota-2.1.3 { file size test.db } {4096}
83: do_test quota-2.1.4 {
84: catchsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
85: } {1 {database or disk is full}}
86: do_test quota-2.1.5 { set ::quota } {4096 5120}
87:
88: set ::quota_request_ok 1
89: set ::quota [list]
90: do_test quota-2.2.1 {
91: execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
92: } {}
93: do_test quota-2.2.2 { set ::quota } {4096 5120}
94: do_test quota-2.2.3 { file size test.db } {5120}
95: unset ::quota_request_ok
96:
97: do_test quota-2.3.1 {
98: sqlite3 db2 bak.db
99: db2 close
100: } {}
101:
102: do_test quota-2.4.1 {
103: sqlite3_quota_shutdown
104: } {SQLITE_MISUSE}
105: set ::quota [list]
106: do_test quota-2.4.2 {
107: catchsql { INSERT INTO t1 VALUES(3, randomblob(1100)) }
108: } {1 {database or disk is full}}
109: do_test quota-2.4.3 { set ::quota } {5120 6144}
110: do_test quota-2.4.4 { file size test.db } {5120}
111: do_test quota-2.4.99 {
112: db close
113: sqlite3_quota_shutdown
114: } {SQLITE_OK}
115:
116: #-------------------------------------------------------------------------
117: # Try some tests with more than one connection to a database file. Still
118: # in rollback mode.
119: #
120: # quota-3.1.*: Two connections to a single database file.
121: #
122: # quota-3.2.*: Two connections to each of several database files (that
123: # are in the same quota group).
124: #
125: proc quota_check {filename limitvar size} {
126: upvar $limitvar limit
127: lappend ::quota [set limit] $size
128: if {[info exists ::quota_request_ok]} { set limit $size }
129: }
130:
131: do_test quota-3.1.1 {
132: forcedelete test.db
133: sqlite3_quota_initialize "" 1
134: sqlite3_quota_set *test.db 4096 quota_check
135: } {SQLITE_OK}
136: do_test quota-3.1.2 {
137: sqlite3 db test.db
138: execsql {
139: PRAGMA page_size = 1024;
140: PRAGMA journal_mode = delete;
141: PRAGMA auto_vacuum = off;
142: CREATE TABLE t1(a PRIMARY KEY, b);
143: INSERT INTO t1 VALUES(1, 'one');
144: }
145: file size test.db
146: } {3072}
147: do_test quota-3.1.3 {
148: sqlite3 db2 test.db
149: set ::quota [list]
150: execsql { CREATE TABLE t2(a, b) } db2
151: set ::quota
152: } {}
153: do_test quota-3.1.4 {
154: catchsql { CREATE TABLE t3(a, b) }
155: } {1 {database or disk is full}}
156: do_test quota-3.1.5 {
157: set ::quota_request_ok 1
158: execsql { CREATE TABLE t3(a, b) }
159: } {}
160: do_test quota-3.1.6 {
161: db close
162: db2 close
163: sqlite3_quota_set *test.db 0 {}
164: } {SQLITE_OK}
165:
166: do_test quota-3.2.1 {
167: delete_file force test.db test2.db
168:
169: sqlite3_quota_set * 4096 {}
170: sqlite3 db1a test.db
171: sqlite3 db2a test2.db
172:
173: foreach db {db1a db2a} {
174: execsql {
175: PRAGMA page_size = 1024;
176: PRAGMA journal_mode = delete;
177: PRAGMA auto_vacuum = off;
178: CREATE TABLE t1(a, b);
179: } $db
180: }
181:
182: sqlite3 db1b test.db
183: sqlite3 db2b test2.db
184:
185: list [file size test.db] [file size test2.db]
186: } {2048 2048}
187:
188: catch { unset ::quota_request_ok }
189:
190: do_test quota-3.2.2 { execsql { INSERT INTO t1 VALUES('x', 'y') } db1a } {}
191: do_test quota-3.2.3 { execsql { INSERT INTO t1 VALUES('v', 'w') } db1b } {}
192: do_test quota-3.2.4 { execsql { INSERT INTO t1 VALUES('t', 'u') } db2a } {}
193: do_test quota-3.2.5 { execsql { INSERT INTO t1 VALUES('r', 's') } db2b } {}
194:
195: do_test quota-3.2.6 {
196: catchsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a
197: } {1 {database or disk is full}}
198: do_test quota-3.2.7 {
199: catchsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b
200: } {1 {database or disk is full}}
201: do_test quota-3.2.8 {
202: catchsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a
203: } {1 {database or disk is full}}
204: do_test quota-3.2.9 {
205: catchsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b
206: } {1 {database or disk is full}}
207:
208: set ::quota [list]
209: proc quota_callback {file limitvar size} {
210: upvar $limitvar limit
211: if {$::tcl_platform(platform)=="windows"} {
212: set file [ lindex [string map {\\ \/} $file] 0 ]
213: }
214: lappend ::quota $file $size
215: set limit 0
216: }
217: sqlite3_quota_set * 4096 quota_callback
218: do_test quota-3.3.1 {
219: execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a
220: execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b
221: execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a
222: execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b
223: set ::quota
224: } [list [file join [pwd] test.db] 5120]
225:
226: do_test quota-3.2.X {
227: foreach db {db1a db2a db2b db1b} { catch { $db close } }
228: sqlite3_quota_set * 0 {}
229: } {SQLITE_OK}
230:
231: #-------------------------------------------------------------------------
232: # Quotas are deleted when unused and when their limit is set to zero
233: #
234:
235: # Return a list of all currently defined quotas. Each quota is identified
236: # by its pattern.
237: proc quota_list {} {
238: set allq {}
239: foreach q [sqlite3_quota_dump] {
240: lappend allq [lindex $q 0]
241: }
242: return [lsort $allq]
243: }
244: proc quota_size {name} {
245: set allq {}
246: foreach q [sqlite3_quota_dump] {
247: if {[lindex $q 0]==$name} {return [lindex $q 2]}
248: }
249: return 0
250: }
251:
252: do_test quota-4.1.1 {
253: sqlite3_quota_set *test.db 0 {}
254: quota_list
255: } {}
256: do_test quota-4.1.2 {
257: sqlite3_quota_set *test.db 4096 {}
258: quota_list
259: } {*test.db}
260: do_test quota-4.1.3 {
261: sqlite3_quota_set *test2.db 0 {}
262: quota_list
263: } {*test.db}
264: do_test quota-4.1.4 {
265: sqlite3_quota_set *test2.db 100000 {}
266: quota_list
267: } {*test.db *test2.db}
268: do_test quota-4.1.5 {
269: sqlite3_quota_set *test.db 0 {}
270: quota_list
271: } {*test2.db}
272: do_test quota-4.1.6 {
273: forcedelete test2.db test2.db-journal test2.db-wal
274: sqlite3 db test2.db
275: db eval {CREATE TABLE t2(x); INSERT INTO t2 VALUES('tab-t2');}
276: quota_list
277: } {*test2.db}
278: do_test quota-4.1.7 {
279: catchsql {INSERT INTO t2 VALUES(zeroblob(200000))}
280: } {1 {database or disk is full}}
281: do_test quota-4.1.8 {
282: sqlite3 db2 test2.db
283: db2 eval {SELECT * FROM t2}
284: } {tab-t2}
285: do_test quota-4.1.9 {
286: sqlite3_quota_set *test2.db 0 {}
287: catchsql {INSERT INTO t2 VALUES(zeroblob(200000))}
288: } {0 {}}
289: do_test quota-4.1.10 {
290: quota_list
291: } {*test2.db}
292: do_test quota-4.1.11 {
293: db2 close
294: quota_list
295: } {*test2.db}
296: do_test quota-4.1.12 {
297: db close
298: quota_list
299: } {}
300:
301: do_test quota-4.2.1 {
302: sqlite3_quota_set A 1000 {}
303: sqlite3_quota_set B 1000 {}
304: sqlite3_quota_set C 1000 {}
305: sqlite3_quota_set D 1000 {}
306: quota_list
307: } {A B C D}
308: do_test quota-4.2.2 {
309: sqlite3_quota_set C 0 {}
310: sqlite3_quota_set B 0 {}
311: quota_list
312: } {A D}
313: do_test quota-4.2.3 {
314: sqlite3_quota_set A 0 {}
315: sqlite3_quota_set D 0 {}
316: quota_list
317: } {}
318: do_test quota-4.2.4 {
319: sqlite3_quota_set A 1000 {}
320: sqlite3_quota_set B 1000 {}
321: sqlite3_quota_set C 1000 {}
322: sqlite3_quota_set A 0 {}
323: sqlite3_quota_set B 0 {}
324: sqlite3_quota_set C 0 {}
325: quota_list
326: } {}
327: do_test quota-4.2.5 {
328: sqlite3_quota_set A 1000 {}
329: sqlite3_quota_set B 1000 {}
330: sqlite3_quota_set C 1000 {}
331: sqlite3_quota_set C 0 {}
332: sqlite3_quota_set B 0 {}
333: sqlite3_quota_set A 0 {}
334: quota_list
335: } {}
336:
337: do_test quota-4.3.1 {
338: sqlite3_quota_set A 1000 quota_callback
339: sqlite3 db A
340: sqlite3_quota_set A 0 quota_callback
341: db close
342: quota_list
343: } {}
344:
345: unset -nocomplain quotagroup
346: if {$tcl_platform(platform)=="windows"} {
347: set quotagroup *\\quota-test-A?.db
348: } else {
349: set quotagroup */quota-test-A?.db
350: }
351: foreach file [glob -nocomplain quota-test-A*] {
352: forcedelete $file
353: }
354: do_test quota-4.4.1 {
355: set ::quota {}
356: sqlite3_quota_set $::quotagroup 10000 quota_callback
357: file delete -force ./quota-test-A1.db ./quota-test-A2.db
358: sqlite3 db ./quota-test-A1.db
359: db eval {
360: CREATE TABLE t1(x);
361: INSERT INTO t1 VALUES(randomblob(5000));
362: }
363: quota_list
364: } [list $quotagroup]
365: do_test quota-4.4.2 {
366: expr {$::quota==""}
367: } {1}
368: do_test quota-4.4.3 {
369: db close
370: sqlite3 db ./quota-test-A2.db
371: db eval {
372: CREATE TABLE t1(x);
373: INSERT INTO t1 VALUES(randomblob(5000));
374: }
375: quota_list
376: } [list $quotagroup]
377: do_test quota-4.4.4 {
378: expr {$::quota!=""}
379: } {1}
380: do_test quota-4.4.5 {
381: db close
382: sqlite3_quota_set $::quotagroup 0 {}
383: sqlite3_quota_dump
384: } {}
385: do_test quota-4.4.6 {
386: sqlite3_quota_set $quotagroup 10000 quota_callback
387: sqlite3 db quota-test-A1.db
388: db eval {SELECT count(*) FROM sqlite_master}
389: quota_size $quotagroup
390: } [file size quota-test-A1.db]
391: do_test quota-4.4.7 {
392: sqlite3_quota_file quota-test-A2.db
393: quota_size $::quotagroup
394: } [expr {[file size quota-test-A1.db]+[file size quota-test-A2.db]}]
395:
396: unset -nocomplain quotagroup
397: if {$tcl_platform(platform)=="windows"} {
398: set quotagroup *\\quota-test-B*
399: } else {
400: set quotagroup */quota-test-B*
401: }
402: foreach file [glob -nocomplain quota-test-B*] {
403: forcedelete $file
404: }
405: do_test quota-4.5.1 {
406: sqlite3_quota_set $::quotagroup 100000 quota_callback
407: quota_size $::quotagroup
408: } {0}
409: do_test quota-4.5.2 {
410: sqlite3_quota_file quota-test-B1.txt
411: quota_size $::quotagroup
412: } {0}
413: proc add_to_file {name n} {
414: set out [open $name a]
415: fconfigure $out -translation binary
416: puts -nonewline $out [string repeat x $n]
417: close $out
418: }
419: do_test quota-4.5.3 {
420: add_to_file quota-test-B1.txt 123
421: sqlite3_quota_file quota-test-B1.txt
422: quota_size $::quotagroup
423: } {123}
424: do_test quota-4.5.4 {
425: add_to_file quota-test-B2.txt 234
426: sqlite3_quota_file quota-test-B2.txt
427: quota_size $::quotagroup
428: } {357}
429: do_test quota-4.5.5 {
430: add_to_file quota-test-B1.txt 2000
431: sqlite3_quota_file quota-test-B1.txt
432: quota_size $::quotagroup
433: } {2357}
434: do_test quota-4.5.6 {
435: forcedelete quota-test-B1.txt
436: sqlite3_quota_file quota-test-B1.txt
437: quota_size $::quotagroup
438: } {234}
439: do_test quota-4.5.7 {
440: forcedelete quota-test-B2.txt
441: sqlite3_quota_file quota-test-B2.txt
442: quota_size $::quotagroup
443: } {0}
444: do_test quota-4.5.8 {
445: add_to_file quota-test-B3.txt 1234
446: sqlite3_quota_file quota-test-B3.txt
447: quota_size $::quotagroup
448: } {1234}
449: do_test quota-4.5.9 {
450: sqlite3_quota_set $quotagroup 0 {}
451: quota_size $::quotagroup
452: } {0}
453:
454: do_test quota-4.9.1 {
455: db close
456: sqlite3_quota_set A 1000 quota_callback
457: sqlite3_quota_shutdown
458: } {SQLITE_OK}
459: do_test quota-4.9.2 {
460: quota_list
461: } {}
462:
463: #-------------------------------------------------------------------------
464: # The following tests test that the quota VFS handles malloc and IO
465: # errors.
466: #
467:
468: sqlite3_quota_initialize "" 1
469: sqlite3_quota_set *test.db 4096 {}
470:
471: do_faultsim_test quota-5.1 -prep {
472: catch {db close}
473: } -body {
474: sqlite3 db test2.db
475: }
476: do_faultsim_test quota-5.2 -prep {
477: catch {db close}
478: } -body {
479: sqlite3 db test.db
480: }
481:
482: catch { db close }
483: forcedelete test.db
484:
485: do_test quota-5.3.prep {
486: sqlite3 db test.db
487: execsql {
488: PRAGMA auto_vacuum = 1;
489: PRAGMA page_size = 1024;
490: CREATE TABLE t1(a, b);
491: INSERT INTO t1 VALUES(10, zeroblob(1200));
492: }
493: faultsim_save_and_close
494: } {}
495: do_faultsim_test quota-5.3 -prep {
496: faultsim_restore_and_reopen
497: } -body {
498: execsql { DELETE FROM t1 }
499: }
500:
501: do_test quota-5.4.1 {
502: catch { db close }
503: forcedelete test.db
504: file mkdir test.db
505: list [catch { sqlite3 db test.db } msg] $msg
506: } {1 {unable to open database file}}
507:
508: do_faultsim_test quota-5.5 -prep {
509: catch { sqlite3_quota_shutdown }
510: } -body {
511: sqlite3_quota_initialize "" 1
512: }
513:
514: do_faultsim_test quota-5.6 -prep {
515: catch { sqlite3_quota_shutdown }
516: sqlite3_quota_initialize "" 1
517: } -body {
518: sqlite3_quota_set * 4096 {}
519: }
520:
521: catch { sqlite3_quota_shutdown }
522: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to quota.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