Return to mallocC.test CVS log

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

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

1.1       misho       1: # 2007 Aug 13
                      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 tests aspects of the malloc failure while parsing
                     13: # CREATE TABLE statements in auto_vacuum mode.
                     14: #
                     15: # $Id: mallocC.test,v 1.10 2009/04/11 16:27:50 drh Exp $
                     16: 
                     17: set testdir [file dirname $argv0]
                     18: source $testdir/tester.tcl
                     19: source $testdir/malloc_common.tcl
                     20: 
                     21: # Only run these tests if memory debugging is turned on.
                     22: #
                     23: if {!$MEMDEBUG} {
                     24:    puts "Skipping mallocC tests: not compiled with -DSQLITE_MEMDEBUG..."
                     25:    finish_test
                     26:    return
                     27: }
                     28: 
                     29: proc do_mallocC_test {tn args} {
                     30:   array set ::mallocopts $args
                     31:   #set sum [allcksum db]
                     32: 
                     33:   for {set ::n 1} {true} {incr ::n} {
                     34: 
                     35:     # Run the SQL. Malloc number $::n is set to fail. A malloc() failure
                     36:     # may or may not be reported.
                     37:     sqlite3_memdebug_fail $::n -repeat 1
                     38:     do_test mallocC-$tn.$::n.1 {
                     39:       set res [catchsql [string trim $::mallocopts(-sql)]]
                     40:       set rc [expr { 
                     41:         0==[string compare $res {1 {out of memory}}] ||
                     42:         [db errorcode] == 3082 ||
                     43:         0==[lindex $res 0]
                     44:       }]
                     45:       if {$rc!=1} {
                     46:         puts "Error: $res"
                     47:       }
                     48:       set rc
                     49:     } {1}
                     50: 
                     51:     # If $::n is greater than the number of malloc() calls required to
                     52:     # execute the SQL, then this test is finished. Break out of the loop.
                     53:     set nFail [sqlite3_memdebug_fail -1]
                     54:     if {$nFail==0} {
                     55:       break
                     56:     }
                     57: 
                     58:     # Recover from the malloc failure.
                     59:     #
                     60:     # Update: The new malloc() failure handling means that a transaction may
                     61:     # still be active even if a malloc() has failed. But when these tests were
                     62:     # written this was not the case. So do a manual ROLLBACK here so that the
                     63:     # tests pass.
                     64:     do_test mallocC-$tn.$::n.2 {
                     65:       catch {
                     66:         execsql {
                     67:           ROLLBACK;
                     68:         }
                     69:       }
                     70:       expr 0
                     71:     } {0}
                     72: 
                     73:     # Checksum the database.
                     74:     #do_test mallocC-$tn.$::n.3 {
                     75:     #  allcksum db
                     76:     #} $sum
                     77: 
                     78:     #integrity_check mallocC-$tn.$::n.4
                     79:   }
                     80:   unset ::mallocopts
                     81: }
                     82: 
                     83: sqlite3_extended_result_codes db 1
                     84: 
                     85: execsql {
                     86:   PRAGMA auto_vacuum=1;
                     87:   CREATE TABLE t0(a, b, c);
                     88: }
                     89: 
                     90: # The number of memory allocation failures is different on 64-bit
                     91: # and 32-bit systems due to larger structures on 64-bit systems
                     92: # overflowing the lookaside more often.  To debug problems, it is
                     93: # sometimes helpful to reduce the size of the lookaside allocation
                     94: # blocks.  But this is normally disabled.
                     95: #
                     96: if {0} {
                     97:   db close
                     98:   sqlite3_shutdown
                     99:   sqlite3_config_lookaside 50 500
                    100:   sqlite3_initialize
                    101:   autoinstall_test_functions
                    102:   sqlite3 db test.db
                    103: }
                    104: 
                    105: do_mallocC_test 1 -sql {
                    106:   BEGIN;
                    107:   -- Allocate 32 new root pages. This will exercise the 'extract specific 
                    108:   -- page from the freelist' code when in auto-vacuum mode (see the
                    109:   -- allocatePage() routine in btree.c).
                    110:   CREATE TABLE t1(a UNIQUE, b UNIQUE, c UNIQUE);
                    111:   CREATE TABLE t2(a UNIQUE, b UNIQUE, c UNIQUE);
                    112:   CREATE TABLE t3(a UNIQUE, b UNIQUE, c UNIQUE);
                    113:   CREATE TABLE t4(a UNIQUE, b UNIQUE, c UNIQUE);
                    114:   CREATE TABLE t5(a UNIQUE, b UNIQUE, c UNIQUE);
                    115:   CREATE TABLE t6(a UNIQUE, b UNIQUE, c UNIQUE);
                    116:   CREATE TABLE t7(a UNIQUE, b UNIQUE, c UNIQUE);
                    117:   CREATE TABLE t8(a UNIQUE, b UNIQUE, c UNIQUE);
                    118: 
                    119:   ROLLBACK;
                    120: }
                    121: 
                    122: finish_test