Annotation of embedaddon/sqlite3/test/malloc3.test, revision 1.1.1.1
1.1 misho 1: # 2005 November 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: #
12: # This file contains tests to ensure that the library handles malloc() failures
13: # correctly. The emphasis of these tests are the _prepare(), _step() and
14: # _finalize() calls.
15: #
16: # $Id: malloc3.test,v 1.24 2008/10/14 15:54:08 drh Exp $
17:
18: set testdir [file dirname $argv0]
19: source $testdir/tester.tcl
20: source $testdir/malloc_common.tcl
21:
22: # Only run these tests if memory debugging is turned on.
23: #
24: if {!$MEMDEBUG} {
25: puts "Skipping malloc3 tests: not compiled with -DSQLITE_MEMDEBUG..."
26: finish_test
27: return
28: }
29:
30: #--------------------------------------------------------------------------
31: # NOTES ON RECOVERING FROM A MALLOC FAILURE
32: #
33: # The tests in this file test the behaviours described in the following
34: # paragraphs. These tests test the behaviour of the system when malloc() fails
35: # inside of a call to _prepare(), _step(), _finalize() or _reset(). The
36: # handling of malloc() failures within ancillary procedures is tested
37: # elsewhere.
38: #
39: # Overview:
40: #
41: # Executing a statement is done in three stages (prepare, step and finalize). A
42: # malloc() failure may occur within any stage. If a memory allocation fails
43: # during statement preparation, no statement handle is returned. From the users
44: # point of view the system state is as if _prepare() had never been called.
45: #
46: # If the memory allocation fails during the _step() or _finalize() calls, then
47: # the database may be left in one of two states (after finalize() has been
48: # called):
49: #
50: # * As if the neither _step() nor _finalize() had ever been called on
51: # the statement handle (i.e. any changes made by the statement are
52: # rolled back).
53: # * The current transaction may be rolled back. In this case a hot-journal
54: # may or may not actually be present in the filesystem.
55: #
56: # The caller can tell the difference between these two scenarios by invoking
57: # _get_autocommit().
58: #
59: #
60: # Handling of sqlite3_reset():
61: #
62: # If a malloc() fails while executing an sqlite3_reset() call, this is handled
63: # in the same way as a failure within _finalize(). The statement handle
64: # is not deleted and must be passed to _finalize() for resource deallocation.
65: # Attempting to _step() or _reset() the statement after a failed _reset() will
66: # always return SQLITE_NOMEM.
67: #
68: #
69: # Other active SQL statements:
70: #
71: # The effect of a malloc failure on concurrently executing SQL statements,
72: # particularly when the statement is executing with READ_UNCOMMITTED set and
73: # the malloc() failure mandates statement rollback only. Currently, if
74: # transaction rollback is required, all other vdbe's are aborted.
75: #
76: # Non-transient mallocs in btree.c:
77: # * The Btree structure itself
78: # * Each BtCursor structure
79: #
80: # Mallocs in pager.c:
81: # readMasterJournal() - Space to read the master journal name
82: # pager_delmaster() - Space for the entire master journal file
83: #
84: # sqlite3pager_open() - The pager structure itself
85: # sqlite3_pagerget() - Space for a new page
86: # pager_open_journal() - Pager.aInJournal[] bitmap
87: # sqlite3pager_write() - For in-memory databases only: history page and
88: # statement history page.
89: # pager_stmt_begin() - Pager.aInStmt[] bitmap
90: #
91: # None of the above are a huge problem. The most troublesome failures are the
92: # transient malloc() calls in btree.c, which can occur during the tree-balance
93: # operation. This means the tree being balanced will be internally inconsistent
94: # after the malloc() fails. To avoid the corrupt tree being read by a
95: # READ_UNCOMMITTED query, we have to make sure the transaction or statement
96: # rollback occurs before sqlite3_step() returns, not during a subsequent
97: # sqlite3_finalize().
98: #--------------------------------------------------------------------------
99:
100: #--------------------------------------------------------------------------
101: # NOTES ON TEST IMPLEMENTATION
102: #
103: # The tests in this file are implemented differently from those in other
104: # files. Instead, tests are specified using three primitives: SQL, PREP and
105: # TEST. Each primitive has a single argument. Primitives are processed in
106: # the order they are specified in the file.
107: #
108: # A TEST primitive specifies a TCL script as its argument. When a TEST
109: # directive is encountered the Tcl script is evaluated. Usually, this Tcl
110: # script contains one or more calls to [do_test].
111: #
112: # A PREP primitive specifies an SQL script as its argument. When a PREP
113: # directive is encountered the SQL is evaluated using database connection
114: # [db].
115: #
116: # The SQL primitives are where the action happens. An SQL primitive must
117: # contain a single, valid SQL statement as its argument. When an SQL
118: # primitive is encountered, it is evaluated one or more times to test the
119: # behaviour of the system when malloc() fails during preparation or
120: # execution of said statement. The Nth time the statement is executed,
121: # the Nth malloc is said to fail. The statement is executed until it
122: # succeeds, i.e. (M+1) times, where M is the number of mallocs() required
123: # to prepare and execute the statement.
124: #
125: # Each time an SQL statement fails, the driver program (see proc [run_test]
126: # below) figures out if a transaction has been automatically rolled back.
127: # If not, it executes any TEST block immediately proceeding the SQL
128: # statement, then reexecutes the SQL statement with the next value of N.
129: #
130: # If a transaction has been automatically rolled back, then the driver
131: # program executes all the SQL specified as part of SQL or PREP primitives
132: # between the current SQL statement and the most recent "BEGIN". Any
133: # TEST block immediately proceeding the SQL statement is evaluated, and
134: # then the SQL statement reexecuted with the incremented N value.
135: #
136: # That make any sense? If not, read the code in [run_test] and it might.
137: #
138: # Extra restriction imposed by the implementation:
139: #
140: # * If a PREP block starts a transaction, it must finish it.
141: # * A PREP block may not close a transaction it did not start.
142: #
143: #--------------------------------------------------------------------------
144:
145:
146: # These procs are used to build up a "program" in global variable
147: # ::run_test_script. At the end of this file, the proc [run_test] is used
148: # to execute the program (and all test cases contained therein).
149: #
150: set ::run_test_script [list]
151: proc TEST {id t} {lappend ::run_test_script -test [list $id $t]}
152: proc PREP {p} {lappend ::run_test_script -prep [string trim $p]}
153: proc DEBUG {s} {lappend ::run_test_script -debug $s}
154:
155: # SQL --
156: #
157: # SQL ?-norollback? <sql-text>
158: #
159: # Add an 'SQL' primitive to the program (see notes above). If the -norollback
160: # switch is present, then the statement is not allowed to automatically roll
161: # back any active transaction if malloc() fails. It must rollback the statement
162: # transaction only.
163: #
164: proc SQL {a1 {a2 ""}} {
165: # An SQL primitive parameter is a list of two elements, a boolean value
166: # indicating if the statement may cause transaction rollback when malloc()
167: # fails, and the sql statement itself.
168: if {$a2 == ""} {
169: lappend ::run_test_script -sql [list true [string trim $a1]]
170: } else {
171: lappend ::run_test_script -sql [list false [string trim $a2]]
172: }
173: }
174:
175: # TEST_AUTOCOMMIT --
176: #
177: # A shorthand test to see if a transaction is active or not. The first
178: # argument - $id - is the integer number of the test case. The second
179: # argument is either 1 or 0, the expected value of the auto-commit flag.
180: #
181: proc TEST_AUTOCOMMIT {id a} {
182: TEST $id "do_test \$testid { sqlite3_get_autocommit \$::DB } {$a}"
183: }
184:
185: #--------------------------------------------------------------------------
186: # Start of test program declaration
187: #
188:
189:
190: # Warm body test. A malloc() fails in the middle of a CREATE TABLE statement
191: # in a single-statement transaction on an empty database. Not too much can go
192: # wrong here.
193: #
194: TEST 1 {
195: do_test $testid {
196: execsql {SELECT tbl_name FROM sqlite_master;}
197: } {}
198: }
199: SQL {
200: CREATE TABLE IF NOT EXISTS abc(a, b, c);
201: }
202: TEST 2 {
203: do_test $testid.1 {
204: execsql {SELECT tbl_name FROM sqlite_master;}
205: } {abc}
206: }
207:
208: # Insert a couple of rows into the table. each insert is in its own
209: # transaction. test that the table is unpopulated before running the inserts
210: # (and hence after each failure of the first insert), and that it has been
211: # populated correctly after the final insert succeeds.
212: #
213: TEST 3 {
214: do_test $testid.2 {
215: execsql {SELECT * FROM abc}
216: } {}
217: }
218: SQL {INSERT INTO abc VALUES(1, 2, 3);}
219: SQL {INSERT INTO abc VALUES(4, 5, 6);}
220: SQL {INSERT INTO abc VALUES(7, 8, 9);}
221: TEST 4 {
222: do_test $testid {
223: execsql {SELECT * FROM abc}
224: } {1 2 3 4 5 6 7 8 9}
225: }
226:
227: # Test a CREATE INDEX statement. Because the table 'abc' is so small, the index
228: # will all fit on a single page, so this doesn't test too much that the CREATE
229: # TABLE statement didn't test. A few of the transient malloc()s in btree.c
230: # perhaps.
231: #
232: SQL {CREATE INDEX abc_i ON abc(a, b, c);}
233: TEST 4 {
234: do_test $testid {
235: execsql {
236: SELECT * FROM abc ORDER BY a DESC;
237: }
238: } {7 8 9 4 5 6 1 2 3}
239: }
240:
241: # Test a DELETE statement. Also create a trigger and a view, just to make sure
242: # these statements don't have any obvious malloc() related bugs in them. Note
243: # that the test above will be executed each time the DELETE fails, so we're
244: # also testing rollback of a DELETE from a table with an index on it.
245: #
246: SQL {DELETE FROM abc WHERE a > 2;}
247: SQL {CREATE TRIGGER abc_t AFTER INSERT ON abc BEGIN SELECT 'trigger!'; END;}
248: SQL {CREATE VIEW abc_v AS SELECT * FROM abc;}
249: TEST 5 {
250: do_test $testid {
251: execsql {
252: SELECT name, tbl_name FROM sqlite_master ORDER BY name;
253: SELECT * FROM abc;
254: }
255: } {abc abc abc_i abc abc_t abc abc_v abc_v 1 2 3}
256: }
257:
258: set sql {
259: BEGIN;DELETE FROM abc;
260: }
261: for {set i 1} {$i < 15} {incr i} {
262: set a $i
263: set b "String value $i"
264: set c [string repeat X $i]
265: append sql "INSERT INTO abc VALUES ($a, '$b', '$c');"
266: }
267: append sql {COMMIT;}
268: PREP $sql
269:
270: SQL {
271: DELETE FROM abc WHERE oid IN (SELECT oid FROM abc ORDER BY random() LIMIT 5);
272: }
273: TEST 6 {
274: do_test $testid.1 {
275: execsql {SELECT count(*) FROM abc}
276: } {94}
277: do_test $testid.2 {
278: execsql {
279: SELECT min(
280: (oid == a) AND 'String value ' || a == b AND a == length(c)
281: ) FROM abc;
282: }
283: } {1}
284: }
285: SQL {
286: DELETE FROM abc WHERE oid IN (SELECT oid FROM abc ORDER BY random() LIMIT 5);
287: }
288: TEST 7 {
289: do_test $testid {
290: execsql {SELECT count(*) FROM abc}
291: } {89}
292: do_test $testid {
293: execsql {
294: SELECT min(
295: (oid == a) AND 'String value ' || a == b AND a == length(c)
296: ) FROM abc;
297: }
298: } {1}
299: }
300: SQL {
301: DELETE FROM abc WHERE oid IN (SELECT oid FROM abc ORDER BY random() LIMIT 5);
302: }
303: TEST 9 {
304: do_test $testid {
305: execsql {SELECT count(*) FROM abc}
306: } {84}
307: do_test $testid {
308: execsql {
309: SELECT min(
310: (oid == a) AND 'String value ' || a == b AND a == length(c)
311: ) FROM abc;
312: }
313: } {1}
314: }
315:
316: set padding [string repeat X 500]
317: PREP [subst {
318: DROP TABLE abc;
319: CREATE TABLE abc(a PRIMARY KEY, padding, b, c);
320: INSERT INTO abc VALUES(0, '$padding', 2, 2);
321: INSERT INTO abc VALUES(3, '$padding', 5, 5);
322: INSERT INTO abc VALUES(6, '$padding', 8, 8);
323: }]
324:
325: TEST 10 {
326: do_test $testid {
327: execsql {SELECT a, b, c FROM abc}
328: } {0 2 2 3 5 5 6 8 8}
329: }
330:
331: SQL {BEGIN;}
332: SQL {INSERT INTO abc VALUES(9, 'XXXXX', 11, 12);}
333: TEST_AUTOCOMMIT 11 0
334: SQL -norollback {UPDATE abc SET a = a + 1, c = c + 1;}
335: TEST_AUTOCOMMIT 12 0
336: SQL {DELETE FROM abc WHERE a = 10;}
337: TEST_AUTOCOMMIT 13 0
338: SQL {COMMIT;}
339:
340: TEST 14 {
341: do_test $testid.1 {
342: sqlite3_get_autocommit $::DB
343: } {1}
344: do_test $testid.2 {
345: execsql {SELECT a, b, c FROM abc}
346: } {1 2 3 4 5 6 7 8 9}
347: }
348:
349: PREP [subst {
350: DROP TABLE abc;
351: CREATE TABLE abc(a, padding, b, c);
352: INSERT INTO abc VALUES(1, '$padding', 2, 3);
353: INSERT INTO abc VALUES(4, '$padding', 5, 6);
354: INSERT INTO abc VALUES(7, '$padding', 8, 9);
355: CREATE INDEX abc_i ON abc(a, padding, b, c);
356: }]
357:
358: TEST 15 {
359: db eval {PRAGMA cache_size = 10}
360: }
361:
362: SQL {BEGIN;}
363: SQL -norllbck {INSERT INTO abc (oid, a, padding, b, c) SELECT NULL, * FROM abc}
364: TEST 16 {
365: do_test $testid {
366: execsql {SELECT a, count(*) FROM abc GROUP BY a;}
367: } {1 2 4 2 7 2}
368: }
369: SQL -norllbck {INSERT INTO abc (oid, a, padding, b, c) SELECT NULL, * FROM abc}
370: TEST 17 {
371: do_test $testid {
372: execsql {SELECT a, count(*) FROM abc GROUP BY a;}
373: } {1 4 4 4 7 4}
374: }
375: SQL -norllbck {INSERT INTO abc (oid, a, padding, b, c) SELECT NULL, * FROM abc}
376: TEST 18 {
377: do_test $testid {
378: execsql {SELECT a, count(*) FROM abc GROUP BY a;}
379: } {1 8 4 8 7 8}
380: }
381: SQL -norllbck {INSERT INTO abc (oid, a, padding, b, c) SELECT NULL, * FROM abc}
382: TEST 19 {
383: do_test $testid {
384: execsql {SELECT a, count(*) FROM abc GROUP BY a;}
385: } {1 16 4 16 7 16}
386: }
387: SQL {COMMIT;}
388: TEST 21 {
389: do_test $testid {
390: execsql {SELECT a, count(*) FROM abc GROUP BY a;}
391: } {1 16 4 16 7 16}
392: }
393:
394: SQL {BEGIN;}
395: SQL {DELETE FROM abc WHERE oid %2}
396: TEST 22 {
397: do_test $testid {
398: execsql {SELECT a, count(*) FROM abc GROUP BY a;}
399: } {1 8 4 8 7 8}
400: }
401: SQL {DELETE FROM abc}
402: TEST 23 {
403: do_test $testid {
404: execsql {SELECT * FROM abc}
405: } {}
406: }
407: SQL {ROLLBACK;}
408: TEST 24 {
409: do_test $testid {
410: execsql {SELECT a, count(*) FROM abc GROUP BY a;}
411: } {1 16 4 16 7 16}
412: }
413:
414: # Test some schema modifications inside of a transaction. These should all
415: # cause transaction rollback if they fail. Also query a view, to cover a bit
416: # more code.
417: #
418: PREP {DROP VIEW abc_v;}
419: TEST 25 {
420: do_test $testid {
421: execsql {
422: SELECT name, tbl_name FROM sqlite_master;
423: }
424: } {abc abc abc_i abc}
425: }
426: SQL {BEGIN;}
427: SQL {CREATE TABLE def(d, e, f);}
428: SQL {CREATE TABLE ghi(g, h, i);}
429: TEST 26 {
430: do_test $testid {
431: execsql {
432: SELECT name, tbl_name FROM sqlite_master;
433: }
434: } {abc abc abc_i abc def def ghi ghi}
435: }
436: SQL {CREATE VIEW v1 AS SELECT * FROM def, ghi}
437: SQL {CREATE UNIQUE INDEX ghi_i1 ON ghi(g);}
438: TEST 27 {
439: do_test $testid {
440: execsql {
441: SELECT name, tbl_name FROM sqlite_master;
442: }
443: } {abc abc abc_i abc def def ghi ghi v1 v1 ghi_i1 ghi}
444: }
445: SQL {INSERT INTO def VALUES('a', 'b', 'c')}
446: SQL {INSERT INTO def VALUES(1, 2, 3)}
447: SQL -norollback {INSERT INTO ghi SELECT * FROM def}
448: TEST 28 {
449: do_test $testid {
450: execsql {
451: SELECT * FROM def, ghi WHERE d = g;
452: }
453: } {a b c a b c 1 2 3 1 2 3}
454: }
455: SQL {COMMIT}
456: TEST 29 {
457: do_test $testid {
458: execsql {
459: SELECT * FROM v1 WHERE d = g;
460: }
461: } {a b c a b c 1 2 3 1 2 3}
462: }
463:
464: # Test a simple multi-file transaction
465: #
466: forcedelete test2.db
467: ifcapable attach {
468: SQL {ATTACH 'test2.db' AS aux;}
469: SQL {BEGIN}
470: SQL {CREATE TABLE aux.tbl2(x, y, z)}
471: SQL {INSERT INTO tbl2 VALUES(1, 2, 3)}
472: SQL {INSERT INTO def VALUES(4, 5, 6)}
473: TEST 30 {
474: do_test $testid {
475: execsql {
476: SELECT * FROM tbl2, def WHERE d = x;
477: }
478: } {1 2 3 1 2 3}
479: }
480: SQL {COMMIT}
481: TEST 31 {
482: do_test $testid {
483: execsql {
484: SELECT * FROM tbl2, def WHERE d = x;
485: }
486: } {1 2 3 1 2 3}
487: }
488: }
489:
490: # Test what happens when a malloc() fails while there are other active
491: # statements. This changes the way sqlite3VdbeHalt() works.
492: TEST 32 {
493: if {![info exists ::STMT32]} {
494: set sql "SELECT name FROM sqlite_master"
495: set ::STMT32 [sqlite3_prepare $::DB $sql -1 DUMMY]
496: do_test $testid {
497: sqlite3_step $::STMT32
498: } {SQLITE_ROW}
499: }
500: }
501: SQL BEGIN
502: TEST 33 {
503: do_test $testid {
504: execsql {SELECT * FROM ghi}
505: } {a b c 1 2 3}
506: }
507: SQL -norollback {
508: -- There is a unique index on ghi(g), so this statement may not cause
509: -- an automatic ROLLBACK. Hence the "-norollback" switch.
510: INSERT INTO ghi SELECT '2'||g, h, i FROM ghi;
511: }
512: TEST 34 {
513: if {[info exists ::STMT32]} {
514: do_test $testid {
515: sqlite3_finalize $::STMT32
516: } {SQLITE_OK}
517: unset ::STMT32
518: }
519: }
520: SQL COMMIT
521:
522: #
523: # End of test program declaration
524: #--------------------------------------------------------------------------
525:
526: proc run_test {arglist iRepeat {pcstart 0} {iFailStart 1}} {
527: if {[llength $arglist] %2} {
528: error "Uneven number of arguments to TEST"
529: }
530:
531: for {set i 0} {$i < $pcstart} {incr i} {
532: set k2 [lindex $arglist [expr 2 * $i]]
533: set v2 [lindex $arglist [expr 2 * $i + 1]]
534: set ac [sqlite3_get_autocommit $::DB] ;# Auto-Commit
535: switch -- $k2 {
536: -sql {db eval [lindex $v2 1]}
537: -prep {db eval $v2}
538: }
539: set nac [sqlite3_get_autocommit $::DB] ;# New Auto-Commit
540: if {$ac && !$nac} {set begin_pc $i}
541: }
542:
543: db rollback_hook [list incr ::rollback_hook_count]
544:
545: set iFail $iFailStart
546: set pc $pcstart
547: while {$pc*2 < [llength $arglist]} {
548:
549: # Id of this iteration:
550: set k [lindex $arglist [expr 2 * $pc]]
551: set iterid "pc=$pc.iFail=$iFail$k"
552: set v [lindex $arglist [expr 2 * $pc + 1]]
553:
554: switch -- $k {
555:
556: -test {
557: foreach {id script} $v {}
558: incr pc
559: }
560:
561: -sql {
562: set ::rollback_hook_count 0
563:
564: set ac [sqlite3_get_autocommit $::DB] ;# Auto-Commit
565: sqlite3_memdebug_fail $iFail -repeat 0
566: set rc [catch {db eval [lindex $v 1]} msg] ;# True error occurs
567: set nac [sqlite3_get_autocommit $::DB] ;# New Auto-Commit
568:
569: if {$rc != 0 && $nac && !$ac} {
570: # Before [db eval] the auto-commit flag was clear. Now it
571: # is set. Since an error occured we assume this was not a
572: # commit - therefore a rollback occured. Check that the
573: # rollback-hook was invoked.
574: do_test malloc3-rollback_hook.$iterid {
575: set ::rollback_hook_count
576: } {1}
577: }
578:
579: set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
580: if {$rc == 0} {
581: # Successful execution of sql. The number of failed malloc()
582: # calls should be equal to the number of benign failures.
583: # Otherwise a malloc() failed and the error was not reported.
584: #
585: if {$nFail!=$nBenign} {
586: error "Unreported malloc() failure"
587: }
588:
589: if {$ac && !$nac} {
590: # Before the [db eval] the auto-commit flag was set, now it
591: # is clear. We can deduce that a "BEGIN" statement has just
592: # been successfully executed.
593: set begin_pc $pc
594: }
595:
596: incr pc
597: set iFail 1
598: integrity_check "malloc3-(integrity).$iterid"
599: } elseif {[regexp {.*out of memory} $msg] || [db errorcode] == 3082} {
600: # Out of memory error, as expected.
601: #
602: integrity_check "malloc3-(integrity).$iterid"
603: incr iFail
604: if {$nac && !$ac} {
605:
606: if {![lindex $v 0] && [db errorcode] != 3082} {
607: # error "Statement \"[lindex $v 1]\" caused a rollback"
608: }
609:
610: for {set i $begin_pc} {$i < $pc} {incr i} {
611: set k2 [lindex $arglist [expr 2 * $i]]
612: set v2 [lindex $arglist [expr 2 * $i + 1]]
613: set catchupsql ""
614: switch -- $k2 {
615: -sql {set catchupsql [lindex $v2 1]}
616: -prep {set catchupsql $v2}
617: }
618: db eval $catchupsql
619: }
620: }
621: } else {
622: error $msg
623: }
624:
625: while {[lindex $arglist [expr 2 * ($pc -1)]] == "-test"} {
626: incr pc -1
627: }
628: }
629:
630: -prep {
631: db eval $v
632: incr pc
633: }
634:
635: -debug {
636: eval $v
637: incr pc
638: }
639:
640: default { error "Unknown switch: $k" }
641: }
642: }
643: }
644:
645: # Turn of the Tcl interface's prepared statement caching facility. Then
646: # run the tests with "persistent" malloc failures.
647: sqlite3_extended_result_codes db 1
648: db cache size 0
649: run_test $::run_test_script 1
650:
651: # Close and reopen the db.
652: db close
653: forcedelete test.db test.db-journal test2.db test2.db-journal
654: sqlite3 db test.db
655: sqlite3_extended_result_codes db 1
656: set ::DB [sqlite3_connection_pointer db]
657:
658: # Turn off the Tcl interface's prepared statement caching facility in
659: # the new connnection. Then run the tests with "transient" malloc failures.
660: db cache size 0
661: run_test $::run_test_script 0
662:
663: sqlite3_memdebug_fail -1
664: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to malloc3.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