Return to fuzz_malloc.test CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test

Annotation of embedaddon/sqlite3/test/fuzz_malloc.test, revision 1.1.1.1

1.1       misho       1: #
                      2: # 2007 May 10
                      3: #
                      4: # The author disclaims copyright to this source code.  In place of
                      5: # a legal notice, here is a blessing:
                      6: #
                      7: #    May you do good and not evil.
                      8: #    May you find forgiveness for yourself and forgive others.
                      9: #    May you share freely, never taking more than you give.
                     10: #
                     11: #***********************************************************************
                     12: #
                     13: # This file tests malloc failures in concert with fuzzy SQL generation.
                     14: #
                     15: # $Id: fuzz_malloc.test,v 1.10 2008/08/20 16:35:10 drh Exp $
                     16: 
                     17: set testdir [file dirname $argv0]
                     18: source $testdir/tester.tcl
                     19: 
                     20: ifcapable !memdebug {
                     21:   finish_test
                     22:   return
                     23: }
                     24: 
                     25: source $testdir/malloc_common.tcl
                     26: source $testdir/fuzz_common.tcl
                     27: 
                     28: if {[info exists G(isquick)]} {
                     29:   set ::REPEATS 20
                     30: } elseif {[info exists G(issoak)]} {
                     31:   set ::REPEATS 100
                     32: } else {
                     33:   set ::REPEATS 40
                     34: }
                     35: 
                     36: #
                     37: # Usage: do_fuzzy_malloc_test <testname> ?<options>?
                     38: # 
                     39: #     -template
                     40: #     -sqlprep
                     41: #     -repeats
                     42: #     
                     43: proc do_fuzzy_malloc_test {testname args} {
                     44:   set ::fuzzyopts(-repeats) $::REPEATS
                     45:   set ::fuzzyopts(-sqlprep) {}
                     46:   array set ::fuzzyopts $args
                     47: 
                     48:   sqlite3_memdebug_fail -1
                     49:   db close
                     50:   delete_file test.db test.db-journal
                     51:   sqlite3 db test.db
                     52:   set ::prep $::fuzzyopts(-sqlprep)
                     53:   execsql $::prep
                     54:   set jj 0
                     55:   for {set ii 0} {$ii < $::fuzzyopts(-repeats)} {incr ii} {
                     56:     expr srand($jj)
                     57:     incr jj
                     58:     set ::sql [subst $::fuzzyopts(-template)]
                     59:     # puts fuzyy-sql=\[$::sql\]; flush stdout
                     60:     foreach {rc res} [catchsql "$::sql"] {}
                     61:     if {$rc==0} {
                     62:       do_malloc_test $testname-$ii -sqlbody $::sql -sqlprep $::prep
                     63:     } else {
                     64:       incr ii -1
                     65:     }
                     66:   }
                     67: }
                     68: 
                     69: #----------------------------------------------------------------
                     70: # Test malloc failure during parsing (and execution) of a fuzzily 
                     71: # generated expressions.
                     72: #
                     73: do_fuzzy_malloc_test fuzzy_malloc-1 -template {Select [Expr]}
                     74: do_fuzzy_malloc_test fuzzy_malloc-2 -template {[Select]}
                     75: 
                     76: set ::SQLPREP {
                     77:   BEGIN;
                     78:     CREATE TABLE abc(a, b, c);
                     79:     CREATE TABLE def(a, b, c);
                     80:     CREATE TABLE ghi(a, b, c);
                     81:     INSERT INTO abc VALUES(1.5, 3, 'a short string');
                     82:     INSERT INTO def VALUES(NULL, X'ABCDEF', 
                     83:         'a longer string. Long enough that it doesn''t fit in Mem.zShort');
                     84:     INSERT INTO ghi VALUES(zeroblob(1000), 'hello world', -1257900987654321);
                     85:   COMMIT;
                     86: }
                     87: set ::TableList  [list abc def ghi]
                     88: set ::ColumnList [list a b c]
                     89: 
                     90: do_fuzzy_malloc_test fuzzy_malloc-3 \
                     91:   -template {[Select]}              \
                     92:   -sqlprep $::SQLPREP
                     93: 
                     94: finish_test