-C The\smalloc.test\sscript\snow\spasses\sall\stests\swith\sno\serrors.\s(CVS\s4271)
-D 2007-08-22T20:18:22
+C All\sof\sthe\smalloc\stest\scases\srun.\s\sStill\sseeing\sfailures\sin\smalloc4.test.\s(CVS\s4272)
+D 2007-08-22T22:04:37
F Makefile.in 0c0e53720f658c7a551046442dd7afba0b72bfbe
F Makefile.linux-gcc 65241babba6faf1152bf86574477baab19190499
F README 9c4e2d6706bdcc3efdd773ce752a8cdab4f90028
F src/malloc.c 8078d4c3f9217c0bb018e432d8655c14996bb107
F src/md5.c c5fdfa5c2593eaee2e32a5ce6c6927c986eaf217
F src/mem1.c 7b023d45dd71944414db469c742457239e24d74d
-F src/mem2.c b707e02fec2cf4d6fce8427d640e90d5003afe9e
+F src/mem2.c 28a0d9306378f97e5cddb7863cb3893d40d1f885
F src/mutex.c 9cf641f556a4119ef90ed41b82f2d5647f81686e
F src/os.c d8f029317c95dcd2887b9f0f154281cdfbd303ad
F src/os.h 399c89cafa93b9ef35c3dc70f77644d10936b535
F src/os_unix.h 5768d56d28240d3fe4537fac08cc85e4fb52279e
F src/os_win.c 29c0e19c1072679a4c7818c49fab2f35d2ad7747
F src/os_win.h 41a946bea10f61c158ce8645e7646b29d44f122b
-F src/pager.c 029a441236e9f504e25a3e2d2944afeae48c297c
+F src/pager.c 54087a81a44e38e30cf8bfed41a73acc9ece84a8
F src/pager.h 53087c6fb9db01aed17c7fd044662a27507e89b8
F src/parse.y 2d2ce439dc6184621fb0b86f4fc5aca7f391a590
F src/pragma.c 9b989506a1b7c8aecd6befb8235e2f57a4aba7e5
F src/test_config.c f0b911bb615d93a192647e76910dce65cbbcf3ad
F src/test_hexio.c 82916f918687502658f02533b519c38cb180db6d
F src/test_loadext.c 22065d601a18878e5542191001f0eaa5d77c0ed8
-F src/test_malloc.c d9ba6be85f9c4a439b19f6e0a72d91c369d72c63
+F src/test_malloc.c 1e24e6bf8dfff1886b57b353911493e7025c2158
F src/test_md5.c 34599caee5b1c73dcf86ca31f55846fab8c19ef7
F src/test_schema.c 12c9de7661d6294eec2d57afbb52e2af1128084f
F src/test_server.c 319f6b1a99bab5f7149387442243d6e65a8ab4eb
F test/lock4.test 49e22396b9be6e047b3d35469f233be79153c9d5
F test/main.test e7212ce1023957c7209778cc87fa932bd79ba89a
F test/malloc.test dbfaedfca734283182db18a64416cf037c33648f
-F test/malloc2.test 4ed7d719542c4570dec9c2ebe2bbdf3a9f3b0d05
-F test/malloc3.test e965954b6f808876a63d3101fd70370320b509a7
-F test/malloc4.test 59cd02f71b363302a04c4e77b97c0a1572eaa210
-F test/malloc5.test 90b1f1ce9f835e6d14fb01be1452169b21d12818
-F test/malloc6.test 025ae0b78542e0ddd000d23f79d93e9be9ba0f15
-F test/malloc7.test 1cf52834509eac7ebeb92105dacd4669f9ca9869
-F test/malloc8.test e4054ca2a87ab1d42255bec009b177ba20b5a487
-F test/malloc9.test 8381041fd89c31fba60c8a1a1c776bb022108572
-F test/mallocA.test 525674e6e0775a9bf85a33f1da1c6bbddc712c30
-F test/mallocB.test 5d4a3dc4931a8c13ef3723c4934af23ff9d60d71
-F test/mallocC.test e470e03fe8b28d79f0a5123601a9653331cc7226
-F test/malloc_common.tcl 7b59db5f0617678f4e5af3a7b3715a1dacd1b8e2
+F test/malloc2.test 96dfa6318d3b7bcd41d4fe7e24d35196d465bf58
+F test/malloc3.test 65d323508c7c4e1fb5569d03a11070b0259ad2fe
+F test/malloc4.test 3f4857ca83168c00900221681fc76de04394968a
+F test/malloc5.test 6f7b96f1bea181d789a7140fd3fabfb0e333d8f5
+F test/malloc6.test 3733b9bd4e039c3239f869c40edbb88172025e2e
+F test/malloc7.test dd66d8f82916becf1d29b6640e4f4855485570f8
+F test/malloc8.test 5ff95278bc73e815e295971afcdd175f6ba19258
+F test/malloc9.test fb99833476bc1a9b0b15573b9a56ae13af843ef9
+F test/mallocA.test f49b8df5e1d2a090830ef5a5f94174c3c930234b
+F test/mallocB.test 56fd615f3fea97180132a89dd1dd2068852ef6a0
+F test/mallocC.test b6b83dea1c3820a70d50b0378481b71bda44bcb3
+F test/malloc_common.tcl 4f07ce6b4a542cc7052e26543406bca439a863f5
F test/manydb.test 8de36b8d33aab5ef295b11d9e95310aeded31af8
F test/memdb.test a67bda4ff90a38f2b19f6c7f95aa7289e051d893
F test/memleak.test d2d2a1ff7105d32dc3fdf691458cf6cba58c7217
F test/tableapi.test 036575a98dcce7c92e9f39056839bbad8a715412
F test/tclsqlite.test 593f3b30221e85786965d9e5670ae4f96b4e4159
F test/temptable.test c36f3e5a94507abb64f7ba23deeb4e1a8a8c3821
-F test/tester.tcl e72b0b8e1b1d9cf20bc641793a3d3c5442a5bbb3
+F test/tester.tcl c9cd05b488392bde9e7e8044d988943a4a52f1fe
F test/thread1.test 776c9e459b75ba905193b351926ac4019b049f35
F test/thread2.test 6d7b30102d600f51b4055ee3a5a19228799049fb
F test/threadtest1.c 6029d9c5567db28e6dc908a0c63099c3ba6c383b
F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0
F www/version3.tcl 890248cf7b70e60c383b0e84d77d5132b3ead42b
F www/whentouse.tcl fc46eae081251c3c181bd79c5faef8195d7991a5
-P b6399dff1370449912391cc5925bdc468b5dade0
-R 3ea0ebd7e3bb257a718fe4ade9660d28
+P db818430e9ea4ef4a4af575784009d5acae785a3
+R 5826e29b4eff86308f2e435b216e5a67
U drh
-Z 59e51dd8c4f548815477ba78b815fe4b
+Z 50c7b8ba17910d7b90bf428d2ab32765
-db818430e9ea4ef4a4af575784009d5acae785a3
\ No newline at end of file
+205d0b881d541db65837ce6cf44d58d607635bc2
\ No newline at end of file
** This file contains the C functions that implement a memory
** allocation subsystem for use by SQLite.
**
-** $Id: mem2.c,v 1.6 2007/08/22 20:18:22 drh Exp $
+** $Id: mem2.c,v 1.7 2007/08/22 22:04:37 drh Exp $
*/
/*
return n;
}
+/*
+** This routine returns the number of successful mallocs remaining until
+** the next simulated malloc failure. -1 is returned if no simulated
+** failure is currently scheduled.
+*/
+int sqlite3_memdebug_pending(void){
+ return mem.iFail-1;
+}
+
/*
** The following two routines are used to assert that no memory
** allocations occur between one call and the next. The use of
** file simultaneously, or one process from reading the database while
** another is writing.
**
-** @(#) $Id: pager.c,v 1.367 2007/08/22 18:54:33 danielk1977 Exp $
+** @(#) $Id: pager.c,v 1.368 2007/08/22 22:04:37 drh Exp $
*/
#ifndef SQLITE_OMIT_DISKIO
#include "sqliteInt.h"
static void pager_resize_hash_table(Pager *pPager, int N){
PgHdr **aHash, *pPg;
assert( N>0 && (N&(N-1))==0 );
+ pagerLeave(pPager);
aHash = sqlite3MallocZero( sizeof(aHash[0])*N );
+ pagerEnter(pPager);
if( aHash==0 ){
/* Failure to rehash is not an error. It is only a performance hit. */
return;
Pager *pPager = sqlite3PagerList;
for( ; pPager && (nReq<0 || nReleased<nReq); pPager=pPager->pNext){
PgHdr *pPg;
- int rc;
+ int rc = SQLITE_OK;
/* In-memory databases should not appear on the pager list */
assert( !MEMDB );
** calling fsync() if this is the first iteration of the outermost
** loop).
*/
- while( SQLITE_OK==(rc = pager_recycle(pPager, i, &pPg)) && pPg) {
+ while( (nReq<0 || nReleased<nReq) &&
+ SQLITE_OK==(rc = pager_recycle(pPager, i, &pPg)) &&
+ pPg
+ ) {
/* We've found a page to free. At this point the page has been
** removed from the page hash-table, free-list and synced-list
** (pFirstSynced). It is still in the all pages (pAll) list.
goto pager_allocate_out;
}
}
+ pagerLeave(pPager);
pPg = sqlite3_malloc( sizeof(*pPg) + pPager->pageSize
+ sizeof(u32) + pPager->nExtra
+ MEMDB*sizeof(PgHistory) );
+ pagerEnter(pPager);
if( pPg==0 ){
rc = SQLITE_NOMEM;
goto pager_allocate_out;
assert( pPager->useJournal );
assert( pPager->aInJournal==0 );
sqlite3PagerPagecount(pPager);
+ pagerLeave(pPager);
pPager->aInJournal = sqlite3MallocZero( pPager->dbSize/8 + 1 );
+ pagerEnter(pPager);
if( pPager->aInJournal==0 ){
rc = SQLITE_NOMEM;
goto failed_to_open_journal;
assert( pPager->origDbSize==0 );
assert( pPager->aInJournal==0 );
sqlite3PagerPagecount(pPager);
+ pagerLeave(pPager);
pPager->aInJournal = sqlite3MallocZero( pPager->dbSize/8 + 1 );
+ pagerEnter(pPager);
if( !pPager->aInJournal ){
rc = SQLITE_NOMEM;
}else{
return SQLITE_OK;
}
assert( pPager->journalOpen );
+ pagerLeave(pPager);
pPager->aInStmt = sqlite3MallocZero( pPager->dbSize/8 + 1 );
+ pagerEnter(pPager);
if( pPager->aInStmt==0 ){
/* sqlite3OsLock(pPager->fd, SHARED_LOCK); */
return SQLITE_NOMEM;
** This file contains code used to implement test interfaces to the
** memory allocation subsystem.
**
-** $Id: test_malloc.c,v 1.2 2007/08/15 20:41:29 drh Exp $
+** $Id: test_malloc.c,v 1.3 2007/08/22 22:04:37 drh Exp $
*/
#include "sqliteInt.h"
#include "tcl.h"
/*
-** Usage: sqlite3_memdebug_fail COUNTER REPEAT
+** Usage: sqlite3_memdebug_fail COUNTER ?REPEAT?
**
** Arrange for a simulated malloc() failure after COUNTER successes.
** If REPEAT is 1 then all subsequent malloc()s fail. If REPEAT is
int iFail;
int iRepeat;
int nFail = 0;
- if( objc!=3 ){
- Tcl_WrongNumArgs(interp, 1, objv, "COUNTER REPEAT");
+ if( objc!=3 && objc!=2 ){
+ Tcl_WrongNumArgs(interp, 1, objv, "COUNTER ?REPEAT?");
return TCL_ERROR;
}
if( Tcl_GetIntFromObj(interp, objv[1], &iFail) ) return TCL_ERROR;
- if( Tcl_GetIntFromObj(interp, objv[2], &iRepeat) ) return TCL_ERROR;
+ if( objc==3 ){
+ if( Tcl_GetIntFromObj(interp, objv[2], &iRepeat) ) return TCL_ERROR;
+ }else{
+ iRepeat = -1;
+ }
#ifdef SQLITE_MEMDEBUG
{
extern int sqlite3_memdebug_fail(int,int);
}
+/*
+** Usage: sqlite3_memdebug_pending
+**
+** Return the number of successful mallocs remaining before the
+** next simulated failure. Return -1 if no simulated failure is
+** currently scheduled.
+*/
+static int test_memdebug_pending(
+ void * clientData,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ extern int sqlite3_memdebug_pending(void);
+ Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_memdebug_pending()));
+ return TCL_OK;
+}
+
+
/*
** Register commands with the TCL interpreter.
*/
{ "sqlite3_memdebug_backtrace", test_memdebug_backtrace },
{ "sqlite3_memdebug_dump", test_memdebug_dump },
{ "sqlite3_memdebug_fail", test_memdebug_fail },
+ { "sqlite3_memdebug_pending", test_memdebug_pending },
};
int i;
for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
# May you share freely, never taking more than you give.
#
#***********************************************************************
+#
# This file attempts to check that the library can recover from a malloc()
# failure when sqlite3_global_recover() is invoked.
#
-# $Id: malloc2.test,v 1.5 2006/09/04 18:54:14 drh Exp $
+# (Later:) The sqlite3_global_recover() interface is now a no-op.
+# Recovery from malloc() failures is automatic. But we keep these
+# tests around because you can never have too many test cases.
+#
+# $Id: malloc2.test,v 1.6 2007/08/22 22:04:37 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
#
-if {[info command sqlite_malloc_stat]==""} {
- puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG=1"
- finish_test
- return
-}
-
-ifcapable !globalrecover {
- finish_test
- return
+ifcapable !memdebug {
+ puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
+ finish_test
+ return
}
# Generate a checksum based on the contents of the database. If the
# Run the SQL. Malloc number $::n is set to fail. A malloc() failure
# may or may not be reported.
- sqlite_malloc_fail $::n
+ sqlite3_memdebug_fail $::n 1
do_test malloc2-$tn.$::n.2 {
set res [catchsql [string trim $::mallocopts(-sql)]]
set rc [expr {
# If $::n is greater than the number of malloc() calls required to
# execute the SQL, then this test is finished. Break out of the loop.
- if {[lindex [sqlite_malloc_stat] 2]>0} {
- sqlite_malloc_fail -1
- break
- }
+ set nFail [sqlite3_memdebug_fail -1 -1]
+ if {$nFail==0} break
# Nothing should work now, because the allocator should refuse to
# allocate any memory.
#
# Update: SQLite now automatically recovers from a malloc() failure.
# So the statement in the test below would work.
-if 0 {
- do_test malloc2-$tn.$::n.3 {
- catchsql {SELECT 'nothing should work'}
- } {1 {out of memory}}
-}
+ if 0 {
+ do_test malloc2-$tn.$::n.3 {
+ catchsql {SELECT 'nothing should work'}
+ } {1 {out of memory}}
+ }
# Recover from the malloc failure.
#
} $sum
integrity_check malloc2-$tn.$::n.6
- if {$::nErr>1} return
+ if {$::nErr>1} return
}
unset ::mallocopts
}
# correctly. The emphasis of these tests are the _prepare(), _step() and
# _finalize() calls.
#
-# $Id: malloc3.test,v 1.10 2007/03/28 01:59:34 drh Exp $
+# $Id: malloc3.test,v 1.11 2007/08/22 22:04:37 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
-if {[info command sqlite_malloc_stat]==""} {
+#
+ifcapable !memdebug {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
set ::rollback_hook_count 0
set ac [sqlite3_get_autocommit $::DB] ;# Auto-Commit
- sqlite_malloc_fail $iFail
+ sqlite3_memdebug_fail $iFail 1
set rc [catch {db eval [lindex $v 1]} msg] ;# True error occurs
set nac [sqlite3_get_autocommit $::DB] ;# New Auto-Commit
} {1}
}
+ set nFail [sqlite3_memdebug_fail -1 -1]
if {$rc == 0} {
# Successful execution of sql. Our "mallocs-until-failure"
# count should be greater than 0. Otherwise a malloc() failed
# and the error was not reported.
- if {[lindex [sqlite_malloc_stat] 2] <= 0} {
+ if {$nFail>0} {
error "Unreported malloc() failure"
}
incr pc
set iFail 1
- sqlite_malloc_fail 0
integrity_check "malloc3-(integrity).$iterid"
} elseif {[regexp {.*out of memory} $msg]} {
# Out of memory error, as expected
run_test $::run_test_script 9 1
# run_test [lrange $::run_test_script 0 3] 0 63
-sqlite_malloc_fail 0
+sqlite3_memdebug_fail -1 -1
db close
-pp_check_for_leaks
-
finish_test
# This file contains tests to ensure that the library handles malloc() failures
# correctly. The emphasis in this file is on sqlite3_column_XXX() APIs.
#
-# $Id: malloc4.test,v 1.3 2006/01/23 07:52:41 danielk1977 Exp $
+# $Id: malloc4.test,v 1.4 2007/08/22 22:04:37 drh Exp $
#---------------------------------------------------------------------------
# NOTES ON EXPECTED BEHAVIOUR
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
-if {[info command sqlite_malloc_stat]==""} {
+if {[info command sqlite3_memdebug_pending]==""} {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
set ::sql $sql
set go 1
for {set n 1} {$go} {incr n} {
- set testid "malloc4-$id.(iFail $n)"
+ set testid "malloc4-$id.$n"
# Prepare the statement
do_test ${testid}.1 {
} {1}
# Set the Nth malloc() to fail.
- sqlite_malloc_fail $n
+ sqlite3_memdebug_fail $n 1
# Test malloc failure in the _name(), _name16(), decltype() and
# decltype16() APIs. Calls that occur after the malloc() failure should
# about explicitly testing them.
#
do_test ${testid}.2.1 {
- set mf1 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
+ set mf1 [expr [sqlite3_memdebug_pending] <= 0]
set ::name8 [sqlite3_column_name $::STMT 0]
- set mf2 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
+ set mf2 [expr [sqlite3_memdebug_pending] <= 0]
expr {$mf1 == $mf2 || $::name8 == ""}
} {1}
do_test ${testid}.2.2 {
- set mf1 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
+ set mf1 [expr [sqlite3_memdebug_pending] <= 0]
set ::name16 [sqlite3_column_name16 $::STMT 0]
set ::name16 [encoding convertfrom unicode $::name16]
set ::name16 [string range $::name16 0 end-1]
- set mf2 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
+ set mf2 [expr [sqlite3_memdebug_pending] <= 0]
expr {$mf1 == $mf2 || $::name16 == ""}
} {1}
do_test ${testid}.2.3 {
- set mf1 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
+ set mf1 [expr [sqlite3_memdebug_pending] <= 0]
set ::name8_2 [sqlite3_column_name $::STMT 0]
- set mf2 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
+ set mf2 [expr [sqlite3_memdebug_pending] <= 0]
expr {$mf1 == $mf2 || $::name8_2 == ""}
} {1}
- set ::mallocFailed [expr [lindex [sqlite_malloc_stat] 2] <= 0]
+ set ::mallocFailed [expr [sqlite3_memdebug_pending] <= 0]
do_test ${testid}.2.4 {
expr {
$::name8 == $::name8_2 && $::name16 == $::name8 && !$::mallocFailed ||
# running sqlite3_step(), make sure that malloc() is not about to fail.
# Memory allocation failures that occur within sqlite3_step() are tested
# elsewhere.
- set mf [lindex [sqlite_malloc_stat] 2]
- sqlite_malloc_fail 0
+ set mf [sqlite3_memdebug_pending]
+ sqlite3_memdebug_fail -1
do_test ${testid}.3 {
sqlite3_step $::STMT
} {SQLITE_ROW}
- sqlite_malloc_fail $mf
+ sqlite3_memdebug_fail $mf
# Test for malloc() failures within _text() and _text16().
#
do_test ${testid}.4.1 {
set ::text8 [sqlite3_column_text $::STMT 0]
- set mf [expr [lindex [sqlite_malloc_stat] 2] <= 0 && !$::mallocFailed]
+ set mf [expr [sqlite3_memdebug_pending] <= 0 && !$::mallocFailed]
expr {$mf==0 || $::text8 == ""}
} {1}
do_test ${testid}.4.2 {
set ::text16 [sqlite3_column_text16 $::STMT 0]
set ::text16 [encoding convertfrom unicode $::text16]
set ::text16 [string range $::text16 0 end-1]
- set mf [expr [lindex [sqlite_malloc_stat] 2] <= 0 && !$::mallocFailed]
+ set mf [expr [sqlite3_memdebug_pending] <= 0 && !$::mallocFailed]
expr {$mf==0 || $::text16 == ""}
} {1}
do_test ${testid}.4.3 {
set ::text8_2 [sqlite3_column_text $::STMT 0]
- set mf [expr [lindex [sqlite_malloc_stat] 2] <= 0 && !$::mallocFailed]
+ set mf [expr [sqlite3_memdebug_pending] <= 0 && !$::mallocFailed]
expr {$mf==0 || $::text8_2 == "" || ($::text16 == "" && $::text8 != "")}
} {1}
# way this can occur is if the string has to be translated from UTF-16 to
# UTF-8 before being converted to a numeric value.
do_test ${testid}.4.4.1 {
- set mf [lindex [sqlite_malloc_stat] 2]
- sqlite_malloc_fail 0
+ set mf [sqlite3_memdebug_pending]
+ sqlite3_memdebug_fail -1
sqlite3_column_text16 $::STMT 0
- sqlite_malloc_fail $mf
+ sqlite3_memdebug_fail $mf
sqlite3_column_int $::STMT 0
} {0}
do_test ${testid}.4.5 {
- set mf [lindex [sqlite_malloc_stat] 2]
- sqlite_malloc_fail 0
+ set mf [sqlite3_memdebug_pending]
+ sqlite3_memdebug_fail -1
sqlite3_column_text16 $::STMT 0
- sqlite_malloc_fail $mf
+ sqlite3_memdebug_fail $mf
sqlite3_column_int64 $::STMT 0
} {0}
do_test ${testid}.4.6 {
- set mf [lindex [sqlite_malloc_stat] 2]
- sqlite_malloc_fail 0
+ set mf [sqlite3_memdebug_pending]
+ sqlite3_memdebug_fail -1
sqlite3_column_text16 $::STMT 0
- sqlite_malloc_fail $mf
+ sqlite3_memdebug_fail $mf
sqlite3_column_double $::STMT 0
} {0.0}
set mallocFailedAfterStep [expr \
- [lindex [sqlite_malloc_stat] 2] <= 0 && !$::mallocFailed
+ [sqlite3_memdebug_pending] <= 0 && !$::mallocFailed
]
- sqlite_malloc_fail 0
+ sqlite3_memdebug_fail -1
# Test that if a malloc() failed the next call to sqlite3_step() returns
# SQLITE_ERROR. If malloc() did not fail, it should return SQLITE_DONE.
#
} [expr {$mallocFailedAfterStep ? "SQLITE_NOMEM" : "SQLITE_OK"}]
if {$::mallocFailed == 0 && $mallocFailedAfterStep == 0} {
- sqlite_malloc_fail 0
+ sqlite3_memdebug_fail -1
set go 0
}
}
do_stmt_test 1 "SELECT * FROM tbl"
-sqlite_malloc_fail 0
+sqlite3_memdebug_fail -1
finish_test
-
# This file contains test cases focused on the two memory-management APIs,
# sqlite3_soft_heap_limit() and sqlite3_release_memory().
#
-# $Id: malloc5.test,v 1.12 2007/08/12 20:07:59 drh Exp $
+# $Id: malloc5.test,v 1.13 2007/08/22 22:04:37 drh Exp $
#---------------------------------------------------------------------------
# NOTES ON EXPECTED BEHAVIOUR
db close
# Only run these tests if memory debugging is turned on.
-if {[info command sqlite_malloc_stat]==""} {
+#
+ifcapable !memdebug {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
} {1 2 3 4 5 6 7 8 9 10 11 12}
db2 close
-sqlite_malloc_outstanding -clearmaxbytes
+puts "Highwater mark: [sqlite3_memory_highwater]"
# The following two test cases each execute a transaction in which
# 10000 rows are inserted into table abc. The first test case is used
execsql "INSERT INTO abc VALUES($i, $i, '[string repeat X 100]');"
}
execsql {COMMIT;}
- set ::nMaxBytes [sqlite_malloc_outstanding -maxbytes]
- if {$::nMaxBytes==""} {set ::nMaxBytes 1000001}
- expr $::nMaxBytes > 1000000
+ set nMaxBytes [sqlite3_memory_highwater 1]
+ puts -nonewline " (Highwater mark: $nMaxBytes) "
+ expr $nMaxBytes > 1000000
} {1}
do_test malloc5-4.2 {
sqlite3_release_memory
- sqlite_malloc_outstanding -clearmaxbytes
sqlite3_soft_heap_limit 100000
+ sqlite3_memory_highwater 1
execsql {BEGIN;}
for {set i 0} {$i < 10000} {incr i} {
execsql "INSERT INTO abc VALUES($i, $i, '[string repeat X 100]');"
}
execsql {COMMIT;}
- set ::nMaxBytes [sqlite_malloc_outstanding -maxbytes]
- if {$::nMaxBytes==""} {set ::nMaxBytes 0}
- expr $::nMaxBytes <= 100000
+ set nMaxBytes [sqlite3_memory_highwater 1]
+ puts -nonewline " (Highwater mark: $nMaxBytes) "
+ expr $nMaxBytes <= 100000
} {1}
do_test malloc5-4.3 {
# Check that the content of table abc is at least roughly as expected.
#
#***********************************************************************
# This file attempts to check the library in an out-of-memory situation.
-# When compiled with -DSQLITE_DEBUG=1, the SQLite library accepts a special
-# command (sqlite_malloc_fail N) which causes the N-th malloc to fail. This
-# special feature is used to see what happens in the library if a malloc
-# were to really fail due to an out-of-memory situation.
#
-# $Id: malloc6.test,v 1.1 2006/06/26 12:50:09 drh Exp $
+# $Id: malloc6.test,v 1.2 2007/08/22 22:04:37 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
#
-if {[info command sqlite_malloc_stat]==""} {
+ifcapable !memdebug {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
}
+source $testdir/malloc_common.tcl
-# Usage: do_malloc_test <test number> <options...>
-#
-# The first argument, <test number>, is an integer used to name the
-# tests executed by this proc. Options are as follows:
-#
-# -tclprep TCL script to run to prepare test.
-# -sqlprep SQL script to run to prepare test.
-# -tclbody TCL script to run with malloc failure simulation.
-# -sqlbody TCL script to run with malloc failure simulation.
-# -cleanup TCL script to run after the test.
-#
-# This command runs a series of tests to verify SQLite's ability
-# to handle an out-of-memory condition gracefully. It is assumed
-# that if this condition occurs a malloc() call will return a
-# NULL pointer. Linux, for example, doesn't do that by default. See
-# the "BUGS" section of malloc(3).
-#
-# Each iteration of a loop, the TCL commands in any argument passed
-# to the -tclbody switch, followed by the SQL commands in any argument
-# passed to the -sqlbody switch are executed. Each iteration the
-# Nth call to sqliteMalloc() is made to fail, where N is increased
-# each time the loop runs starting from 1. When all commands execute
-# successfully, the loop ends.
-#
-proc do_malloc_test {tn args} {
- array unset ::mallocopts
- array set ::mallocopts $args
-
- set ::go 1
- for {set ::n 1} {$::go && $::n < 50000} {incr ::n} {
- do_test malloc6-$tn.$::n {
-
- # Remove all traces of database files test.db and test2.db from the files
- # system. Then open (empty database) "test.db" with the handle [db].
- #
- sqlite_malloc_fail 0
- catch {db close}
- catch {file delete -force test.db}
- catch {file delete -force test.db-journal}
- catch {file delete -force test2.db}
- catch {file delete -force test2.db-journal}
- catch {sqlite3 db test.db}
- set ::DB [sqlite3_connection_pointer db]
-
- # Execute any -tclprep and -sqlprep scripts.
- #
- if {[info exists ::mallocopts(-tclprep)]} {
- eval $::mallocopts(-tclprep)
- }
- if {[info exists ::mallocopts(-sqlprep)]} {
- execsql $::mallocopts(-sqlprep)
- }
-
- # Now set the ${::n}th malloc() to fail and execute the -tclbody and
- # -sqlbody scripts.
- #
- sqlite_malloc_fail $::n
- set ::mallocbody {}
- if {[info exists ::mallocopts(-tclbody)]} {
- append ::mallocbody "$::mallocopts(-tclbody)\n"
- }
- if {[info exists ::mallocopts(-sqlbody)]} {
- append ::mallocbody "db eval {$::mallocopts(-sqlbody)}"
- }
- set v [catch $::mallocbody msg]
-
- # If the test fails (if $v!=0) and the database connection actually
- # exists, make sure the failure code is SQLITE_NOMEM.
- if {$v && [info command db]=="db" && [info exists ::mallocopts(-sqlbody)]
- && [db errorcode]!=7} {
- set v 999
- }
-
- set leftover [lindex [sqlite_malloc_stat] 2]
- if {$leftover>0} {
- if {$leftover>1} {puts "\nLeftover: $leftover\nReturn=$v Message=$msg"}
- set ::go 0
- if {$v} {
- puts "\nError message returned: $msg"
- } else {
- set v {1 1}
- }
- } else {
- set v2 [expr {$msg=="" || $msg=="out of memory"}]
- if {!$v2} {puts "\nError message returned: $msg"}
- lappend v $v2
- }
- } {1 1}
-
- if {[info exists ::mallocopts(-cleanup)]} {
- catch [list uplevel #0 $::mallocopts(-cleanup)] msg
- }
- }
- unset ::mallocopts
-}
set sqlite_os_trace 0
-do_malloc_test 1 -tclprep {
+do_malloc_test malloc6-1 -tclprep {
db close
} -tclbody {
if {[catch {sqlite3 db test.db}]} {
set sqlite_open_file_count
} {0}
-sqlite_malloc_fail 0
finish_test
# This file contains additional out-of-memory checks (see malloc.tcl)
# added to expose a bug in out-of-memory handling for sqlite3_prepare16().
#
-# $Id: malloc7.test,v 1.2 2006/07/26 14:57:30 drh Exp $
+# $Id: malloc7.test,v 1.3 2007/08/22 22:04:37 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
#
-if {[info command sqlite_malloc_stat]==""} {
+ifcapable !memdebug {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
}
+source $testdir/malloc_common.tcl
-# Usage: do_malloc_test <test number> <options...>
-#
-# The first argument, <test number>, is an integer used to name the
-# tests executed by this proc. Options are as follows:
-#
-# -tclprep TCL script to run to prepare test.
-# -sqlprep SQL script to run to prepare test.
-# -tclbody TCL script to run with malloc failure simulation.
-# -sqlbody TCL script to run with malloc failure simulation.
-# -cleanup TCL script to run after the test.
-#
-# This command runs a series of tests to verify SQLite's ability
-# to handle an out-of-memory condition gracefully. It is assumed
-# that if this condition occurs a malloc() call will return a
-# NULL pointer. Linux, for example, doesn't do that by default. See
-# the "BUGS" section of malloc(3).
-#
-# Each iteration of a loop, the TCL commands in any argument passed
-# to the -tclbody switch, followed by the SQL commands in any argument
-# passed to the -sqlbody switch are executed. Each iteration the
-# Nth call to sqliteMalloc() is made to fail, where N is increased
-# each time the loop runs starting from 1. When all commands execute
-# successfully, the loop ends.
-#
-proc do_malloc_test {tn args} {
- array unset ::mallocopts
- array set ::mallocopts $args
-
- set ::go 1
- for {set ::n 1} {$::go && $::n < 50000} {incr ::n} {
- do_test malloc7-$tn.$::n {
-
- # Remove all traces of database files test.db and test2.db from the files
- # system. Then open (empty database) "test.db" with the handle [db].
- #
- sqlite_malloc_fail 0
- catch {db close}
- catch {file delete -force test.db}
- catch {file delete -force test.db-journal}
- catch {file delete -force test2.db}
- catch {file delete -force test2.db-journal}
- catch {sqlite3 db test.db}
- set ::DB [sqlite3_connection_pointer db]
-
- # Execute any -tclprep and -sqlprep scripts.
- #
- if {[info exists ::mallocopts(-tclprep)]} {
- eval $::mallocopts(-tclprep)
- }
- if {[info exists ::mallocopts(-sqlprep)]} {
- execsql $::mallocopts(-sqlprep)
- }
- # Now set the ${::n}th malloc() to fail and execute the -tclbody and
- # -sqlbody scripts.
- #
- sqlite_malloc_fail $::n
- set ::mallocbody {}
- if {[info exists ::mallocopts(-tclbody)]} {
- append ::mallocbody "$::mallocopts(-tclbody)\n"
- }
- if {[info exists ::mallocopts(-sqlbody)]} {
- append ::mallocbody "db eval {$::mallocopts(-sqlbody)}"
- }
- set v [catch $::mallocbody msg]
-
- # If the test fails (if $v!=0) and the database connection actually
- # exists, make sure the failure code is SQLITE_NOMEM.
- if {$v && [info command db]=="db" && [info exists ::mallocopts(-sqlbody)]
- && [db errorcode]!=7} {
- set v 999
- }
-
- set leftover [lindex [sqlite_malloc_stat] 2]
- if {$leftover>0} {
- if {$leftover>1} {puts "\nLeftover: $leftover\nReturn=$v Message=$msg"}
- set ::go 0
- if {$v} {
- puts "\nError message returned: $msg"
- } else {
- set v {1 1}
- }
- } else {
- set v2 [expr {$msg=="" || $msg=="out of memory"}]
- if {!$v2} {puts "\nError message returned: $msg"}
- lappend v $v2
- }
- } {1 1}
-
- if {[info exists ::mallocopts(-cleanup)]} {
- catch [list uplevel #0 $::mallocopts(-cleanup)] msg
- }
- }
- unset ::mallocopts
-}
-
-db eval {
+do_malloc_test malloc7-1 -sqlprep {
CREATE TABLE t1(a,b,c,d);
CREATE INDEX i1 ON t1(b,c);
-}
-
-do_malloc_test 1 -tclbody {
+} -tclbody {
set sql16 [encoding convertto unicode "SELECT * FROM sqlite_master"]
append sql16 "\00\00"
set nbyte [string length $sql16]
- set ::STMT [sqlite3_prepare16 $::DB $sql16 $nbyte DUMMY]
+ set ::STMT [sqlite3_prepare16 db $sql16 $nbyte DUMMY]
sqlite3_finalize $::STMT
}
-
# Ensure that no file descriptors were leaked.
do_test malloc-99.X {
catch {db close}
} {0}
puts open-file-count=$sqlite_open_file_count
-sqlite_malloc_fail 0
finish_test
# This file contains additional out-of-memory checks (see malloc.tcl)
# added to expose a bug in out-of-memory handling for sqlite3_value_text()
#
-# $Id: malloc8.test,v 1.3 2007/05/07 19:31:17 drh Exp $
+# $Id: malloc8.test,v 1.4 2007/08/22 22:04:37 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
#
-if {[info command sqlite_malloc_stat]==""} {
+ifcapable !memdebug {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
}
-# Usage: do_malloc_test <test number> <options...>
-#
-# The first argument, <test number>, is an integer used to name the
-# tests executed by this proc. Options are as follows:
-#
-# -tclprep TCL script to run to prepare test.
-# -sqlprep SQL script to run to prepare test.
-# -tclbody TCL script to run with malloc failure simulation.
-# -sqlbody TCL script to run with malloc failure simulation.
-# -cleanup TCL script to run after the test.
-#
-# This command runs a series of tests to verify SQLite's ability
-# to handle an out-of-memory condition gracefully. It is assumed
-# that if this condition occurs a malloc() call will return a
-# NULL pointer. Linux, for example, doesn't do that by default. See
-# the "BUGS" section of malloc(3).
-#
-# Each iteration of a loop, the TCL commands in any argument passed
-# to the -tclbody switch, followed by the SQL commands in any argument
-# passed to the -sqlbody switch are executed. Each iteration the
-# Nth call to sqliteMalloc() is made to fail, where N is increased
-# each time the loop runs starting from 1. When all commands execute
-# successfully, the loop ends.
-#
-proc do_malloc_test {tn args} {
- array unset ::mallocopts
- array set ::mallocopts $args
-
- set ::go 1
- for {set ::n 1} {$::go && $::n < 50000} {incr ::n} {
- do_test malloc8-$tn.$::n {
-
- sqlite_malloc_fail 0
- catch {db close}
- sqlite3 db test.db
- set ::DB [sqlite3_connection_pointer db]
-
- # Execute any -tclprep and -sqlprep scripts.
- #
- if {[info exists ::mallocopts(-tclprep)]} {
- eval $::mallocopts(-tclprep)
- }
- if {[info exists ::mallocopts(-sqlprep)]} {
- execsql $::mallocopts(-sqlprep)
- }
-
- # Now set the ${::n}th malloc() to fail and execute the -tclbody and
- # -sqlbody scripts.
- #
- sqlite_malloc_fail $::n
- set ::mallocbody {}
- if {[info exists ::mallocopts(-tclbody)]} {
- append ::mallocbody "$::mallocopts(-tclbody)\n"
- }
- if {[info exists ::mallocopts(-sqlbody)]} {
- append ::mallocbody "db eval {$::mallocopts(-sqlbody)}"
- }
- set v [catch $::mallocbody msg]
-
- # If the test fails (if $v!=0) and the database connection actually
- # exists, make sure the failure code is SQLITE_NOMEM.
- if {$v && [info command db]=="db" && [info exists ::mallocopts(-sqlbody)]
- && [db errorcode]!=7} {
- set v 999
- }
-
- set leftover [lindex [sqlite_malloc_stat] 2]
- if {$leftover>0} {
- if {$leftover>1} {puts "\nLeftover: $leftover\nReturn=$v Message=$msg"}
- set ::go 0
- if {$v} {
- puts "\nError message returned: $msg"
- } else {
- set v {1 1}
- }
- } else {
- set v2 [expr {$msg=="" || $msg=="out of memory"}]
- if {!$v2} {puts "\nError message returned: $msg"}
- lappend v $v2
- }
- } {1 1}
-
- if {[info exists ::mallocopts(-cleanup)]} {
- catch [list uplevel #0 $::mallocopts(-cleanup)] msg
- }
- }
- unset ::mallocopts
-}
+source $testdir/malloc_common.tcl
# The setup is a database with UTF-16 encoding that contains a single
# large string. We will be running lots of queries against this
# to fail and for sqlite3_value_text() to return 0 even though
# sqlite3_value_type() returns SQLITE_TEXT.
#
-db close
-file delete -force test.db test.db-journal
-sqlite3 db test.db
-db eval {
+
+do_malloc_test malloc8-1 -sqlprep {
PRAGMA encoding='UTF-16';
CREATE TABLE t1(a);
INSERT INTO t1
VALUES('0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ');
-}
-
-
-do_malloc_test 1 -sqlbody {
+} -sqlbody {
SELECT lower(a), upper(a), quote(a), trim(a), trim('x',a) FROM t1;
}
-do_malloc_test 2 -sqlbody {
+do_malloc_test malloc8-2 -sqlprep {
+ PRAGMA encoding='UTF-16';
+ CREATE TABLE t1(a);
+ INSERT INTO t1
+ VALUES('0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ');
+} -sqlbody {
SELECT replace(a,'x','y'), replace('x',a,'y'), replace('x','y',a)
FROM t1;
}
-do_malloc_test 3 -sqlbody {
+do_malloc_test malloc8-3 -sqlprep {
+ PRAGMA encoding='UTF-16';
+ CREATE TABLE t1(a);
+ INSERT INTO t1
+ VALUES('0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ');
+} -sqlbody {
SELECT length(a), substr(a, 4, 4) FROM t1;
}
-do_malloc_test 4 -sqlbody {
+do_malloc_test malloc8-4 -sqlprep {
+ PRAGMA encoding='UTF-16';
+ CREATE TABLE t1(a);
+ INSERT INTO t1
+ VALUES('0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ');
+} -sqlbody {
SELECT julianday(a,a) FROM t1;
}
-do_malloc_test 5 -sqlbody {
+do_malloc_test malloc8-5 -sqlprep {
+ PRAGMA encoding='UTF-16';
+ CREATE TABLE t1(a);
+ INSERT INTO t1
+ VALUES('0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ');
+} -sqlbody {
SELECT 1 FROM t1 WHERE a LIKE 'hello' ESCAPE NULL;
}
-do_malloc_test 6 -sqlbody {
+do_malloc_test malloc8-6 -sqlprep {
+ PRAGMA encoding='UTF-16';
+ CREATE TABLE t1(a);
+ INSERT INTO t1
+ VALUES('0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ');
+} -sqlbody {
SELECT hex(randomblob(100));
}
set sqlite_open_file_count
} {0}
-sqlite_malloc_fail 0
finish_test
# This file contains additional out-of-memory checks (see malloc.tcl)
# added to expose a bug in out-of-memory handling for sqlite3_prepare().
#
-# $Id: malloc9.test,v 1.1 2007/04/30 21:39:16 drh Exp $
+# $Id: malloc9.test,v 1.2 2007/08/22 22:04:37 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
#
-if {[info command sqlite_malloc_stat]==""} {
+ifcapable !memdebug {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
}
-# Usage: do_malloc_test <test number> <options...>
-#
-# The first argument, <test number>, is an integer used to name the
-# tests executed by this proc. Options are as follows:
-#
-# -tclprep TCL script to run to prepare test.
-# -sqlprep SQL script to run to prepare test.
-# -tclbody TCL script to run with malloc failure simulation.
-# -sqlbody TCL script to run with malloc failure simulation.
-# -cleanup TCL script to run after the test.
-#
-# This command runs a series of tests to verify SQLite's ability
-# to handle an out-of-memory condition gracefully. It is assumed
-# that if this condition occurs a malloc() call will return a
-# NULL pointer. Linux, for example, doesn't do that by default. See
-# the "BUGS" section of malloc(3).
-#
-# Each iteration of a loop, the TCL commands in any argument passed
-# to the -tclbody switch, followed by the SQL commands in any argument
-# passed to the -sqlbody switch are executed. Each iteration the
-# Nth call to sqliteMalloc() is made to fail, where N is increased
-# each time the loop runs starting from 1. When all commands execute
-# successfully, the loop ends.
-#
-proc do_malloc_test {tn args} {
- array unset ::mallocopts
- array set ::mallocopts $args
-
- set ::go 1
- for {set ::n 1} {$::go && $::n < 50000} {incr ::n} {
- do_test malloc9-$tn.$::n {
-
- sqlite_malloc_fail 0
- catch {db close}
- catch {file delete -force test.db}
- catch {file delete -force test.db-journal}
- sqlite3 db test.db
- set ::DB [sqlite3_connection_pointer db]
-
- # Execute any -tclprep and -sqlprep scripts.
- #
- if {[info exists ::mallocopts(-tclprep)]} {
- eval $::mallocopts(-tclprep)
- }
- if {[info exists ::mallocopts(-sqlprep)]} {
- execsql $::mallocopts(-sqlprep)
- }
-
- # Now set the ${::n}th malloc() to fail and execute the -tclbody and
- # -sqlbody scripts.
- #
- sqlite_malloc_fail $::n
- set ::mallocbody {}
- if {[info exists ::mallocopts(-tclbody)]} {
- append ::mallocbody "$::mallocopts(-tclbody)\n"
- }
- if {[info exists ::mallocopts(-sqlbody)]} {
- append ::mallocbody "db eval {$::mallocopts(-sqlbody)}"
- }
- set v [catch $::mallocbody msg]
-
- # If the test fails (if $v!=0) and the database connection actually
- # exists, make sure the failure code is SQLITE_NOMEM.
- if {$v && [info command db]=="db" && [info exists ::mallocopts(-sqlbody)]
- && [db errorcode]!=7} {
- set v 999
- }
-
- set leftover [lindex [sqlite_malloc_stat] 2]
- if {$leftover>0} {
- if {$leftover>1} {puts "\nLeftover: $leftover\nReturn=$v Message=$msg"}
- set ::go 0
- if {$v} {
- puts "\nError message returned: $msg"
- } else {
- set v {1 1}
- }
- } else {
- set v2 [expr {$msg=="" || [regexp {out of memory} $msg]}]
- if {!$v2} {puts "\nError message returned: $msg"}
- lappend v $v2
- }
- } {1 1}
-
- if {[info exists ::mallocopts(-cleanup)]} {
- catch [list uplevel #0 $::mallocopts(-cleanup)] msg
- }
- }
- unset ::mallocopts
-}
-
+source $testdir/malloc_common.tcl
do_malloc_test 1 -tclprep {
set sql {CREATE TABLE t1(x)}
set sqlite_open_file_count
} {0}
-sqlite_malloc_fail 0
finish_test
#***********************************************************************
# This file contains additional out-of-memory checks (see malloc.tcl).
#
-# $Id: mallocA.test,v 1.2 2007/05/12 15:00:15 drh Exp $
+# $Id: mallocA.test,v 1.3 2007/08/22 22:04:37 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
#
-if {[info command sqlite_malloc_stat]==""} {
+ifcapable !memdebug {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
}
-# Usage: do_malloc_test <test number> <options...>
-#
-# The first argument, <test number>, is an integer used to name the
-# tests executed by this proc. Options are as follows:
-#
-# -tclprep TCL script to run to prepare test.
-# -sqlprep SQL script to run to prepare test.
-# -tclbody TCL script to run with malloc failure simulation.
-# -sqlbody TCL script to run with malloc failure simulation.
-# -cleanup TCL script to run after the test.
-#
-# This command runs a series of tests to verify SQLite's ability
-# to handle an out-of-memory condition gracefully. It is assumed
-# that if this condition occurs a malloc() call will return a
-# NULL pointer. Linux, for example, doesn't do that by default. See
-# the "BUGS" section of malloc(3).
-#
-# Each iteration of a loop, the TCL commands in any argument passed
-# to the -tclbody switch, followed by the SQL commands in any argument
-# passed to the -sqlbody switch are executed. Each iteration the
-# Nth call to sqliteMalloc() is made to fail, where N is increased
-# each time the loop runs starting from 1. When all commands execute
-# successfully, the loop ends.
-#
-proc do_malloc_test {tn args} {
- array unset ::mallocopts
- array set ::mallocopts $args
-
- set ::go 1
- for {set ::n 1} {$::go && $::n < 50000} {incr ::n} {
- do_test mallocA-$tn.$::n {
-
- sqlite_malloc_fail 0
- catch {db close}
- catch {file delete -force test.db test.db-journal}
- catch {file copy test.db.bu test.db}
- sqlite3 db test.db
- set ::DB [sqlite3_connection_pointer db]
-
- # Execute any -tclprep and -sqlprep scripts.
- #
- if {[info exists ::mallocopts(-tclprep)]} {
- eval $::mallocopts(-tclprep)
- }
- if {[info exists ::mallocopts(-sqlprep)]} {
- execsql $::mallocopts(-sqlprep)
- }
-
- # Now set the ${::n}th malloc() to fail and execute the -tclbody and
- # -sqlbody scripts.
- #
- sqlite_malloc_fail $::n
- set ::mallocbody {}
- if {[info exists ::mallocopts(-tclbody)]} {
- append ::mallocbody "$::mallocopts(-tclbody)\n"
- }
- if {[info exists ::mallocopts(-sqlbody)]} {
- append ::mallocbody "db eval {$::mallocopts(-sqlbody)}"
- }
- set v [catch $::mallocbody msg]
-
- # If the test fails (if $v!=0) and the database connection actually
- # exists, make sure the failure code is SQLITE_NOMEM.
- if {$v && [info command db]=="db" && [info exists ::mallocopts(-sqlbody)]
- && [db errorcode]!=7} {
- set v 999
- }
-
- set leftover [lindex [sqlite_malloc_stat] 2]
- if {$leftover>0} {
- if {$leftover>1} {puts "\nLeftover: $leftover\nReturn=$v Message=$msg"}
- set ::go 0
- if {$v} {
- puts "\nError message returned: $msg"
- } else {
- set v {1 1}
- }
- } else {
- set v2 [expr {$msg=="" || [regexp {out of memory} $msg]}]
- if {!$v2} {puts "\nError message returned: $msg"}
- lappend v $v2
- }
- } {1 1}
-
- if {[info exists ::mallocopts(-cleanup)]} {
- catch [list uplevel #0 $::mallocopts(-cleanup)] msg
- }
- }
- unset ::mallocopts
-}
+source $testdir/malloc_common.tcl
# Construct a test database
#
}
db close
file copy test.db test.db.bu
-sqlite3 db test.db
-do_malloc_test 1 -sqlbody {
+do_malloc_test 1 -testdb test.db.bu -sqlbody {
ANALYZE
}
-do_malloc_test 2 -sqlbody {
+do_malloc_test 2 -testdb test.db.bu -sqlbody {
REINDEX;
}
-do_malloc_test 3 -sqlbody {
+do_malloc_test 3 -testdb test.db.bu -sqlbody {
REINDEX t1;
}
-do_malloc_test 4 -sqlbody {
+do_malloc_test 4 -testdb test.db.bu -sqlbody {
REINDEX main.t1;
}
-do_malloc_test 5 -sqlbody {
+do_malloc_test 5 -testdb test.db.bu -sqlbody {
REINDEX nocase;
}
} {0}
file delete -force test.db.bu
-sqlite_malloc_fail 0
finish_test
# that they have little in common.
#
#
-# $Id: mallocB.test,v 1.3 2007/07/26 06:50:06 danielk1977 Exp $
+# $Id: mallocB.test,v 1.4 2007/08/22 22:04:37 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
#
-if {[info command sqlite_malloc_stat]==""} {
+ifcapable !memdebug {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
}
+source $testdir/malloc_common.tcl
do_malloc_test mallocB-1 -sqlbody {SELECT - 456}
do_malloc_test mallocB-2 -sqlbody {SELECT - 456.1}
#
do_malloc_test mallocB-6 -sqlbody { SELECT test_auxdata('hello world'); }
-sqlite_malloc_fail 0
finish_test
# This file tests aspects of the malloc failure while parsing
# CREATE TABLE statements in auto_vacuum mode.
#
-# $Id: mallocC.test,v 1.2 2007/08/13 12:58:18 drh Exp $
+# $Id: mallocC.test,v 1.3 2007/08/22 22:04:37 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
#
-if {[info command sqlite_malloc_stat]==""} {
- puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG=1"
- finish_test
- return
+ifcapable !memdebug {
+ puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
+ finish_test
+ return
}
# Generate a checksum based on the contents of the database. If the
# Run the SQL. Malloc number $::n is set to fail. A malloc() failure
# may or may not be reported.
- sqlite_malloc_fail $::n
+ sqlite3_memdebug_fail $::n 1
do_test mallocC-$tn.$::n.1 {
set res [catchsql [string trim $::mallocopts(-sql)]]
set rc [expr {
# If $::n is greater than the number of malloc() calls required to
# execute the SQL, then this test is finished. Break out of the loop.
- if {[lindex [sqlite_malloc_stat] 2]>0} {
- sqlite_malloc_fail -1
+ set nFail [sqlite3_memdebug_fail -1 -1]
+ if {$nFail==0} {
break
}
catch {file delete -force test.db-journal}
catch {file delete -force test2.db}
catch {file delete -force test2.db-journal}
+ if {[info exists ::mallocopts(-testdb)]} {
+ file copy $::mallocopts(-testdb) test.db
+ }
catch {sqlite3 db test.db}
# Execute any -tclprep and -sqlprep scripts.
# This file implements some common TCL routines used for regression
# testing the SQLite library
#
-# $Id: tester.tcl,v 1.85 2007/08/22 20:18:22 drh Exp $
+# $Id: tester.tcl,v 1.86 2007/08/22 22:04:37 drh Exp $
# Make sure tclsqlite3 was compiled correctly. Abort now with an
# error message if not.
catch {db2 close}
catch {db3 close}
- catch {
- pp_check_for_leaks
- }
sqlite3 db {}
# sqlite3_clear_tsd_memdebug
db close
}
}
-# This command checks for outstanding calls to sqlite3_malloc()
-# A list is returned with one entry for each outstanding
-# malloc. Each list entry is itself a list of 5 items, as follows:
-#
-# { <number-bytes> <file-name> <line-number> <test-case> <stack-dump> }
-#
-proc check_for_leaks {} {
- set ret [list]
- set cnt 0
- foreach alloc [sqlite_malloc_outstanding] {
- foreach {nBytes file iLine userstring backtrace} $alloc {}
- set stack [list]
- set skip 0
-
- # The first command in this block will probably fail on windows. This
- # means there will be no stack dump available.
- if {$cnt < 25 && $backtrace!=""} {
- catch {
- set stuff [eval "exec addr2line -e ./testfixture -f $backtrace"]
- foreach {func line} $stuff {
- if {$func != "??" || $line != "??:0"} {
- regexp {.*/(.*)} $line dummy line
- lappend stack "${func}() $line"
- } else {
- if {[lindex $stack end] != "..."} {
- lappend stack "..."
- }
- }
- }
- }
- incr cnt
- }
-
- if {!$skip} {
- lappend ret [list $nBytes $file $iLine $userstring $stack]
- }
- }
- return $ret
-}
-
-# Pretty print a report based on the return value of [check_for_leaks] to
-# stdout.
-proc pp_check_for_leaks {} {
- set l [check_for_leaks]
- set n 0
- foreach leak $l {
- foreach {nBytes file iLine userstring stack} $leak {}
- puts "$nBytes bytes leaked at $file:$iLine ($userstring)"
- foreach frame $stack {
- puts " $frame"
- }
- incr n $nBytes
- }
- puts "Memory leaked: $n bytes in [llength $l] allocations"
- puts ""
-}
-
# If the library is compiled with the SQLITE_DEFAULT_AUTOVACUUM macro set
# to non-zero, then set the global variable $AUTOVACUUM to 1.
set AUTOVACUUM $sqlite_options(default_autovacuum)
projects / thirdparty / sqlite.git / commitdiff
