-C Fix\sbugs\sin\sthe\saltermalloc.test\sand\sincrblob_err.test\sscripts.\s(CVS\s4295)
-D 2007-08-25T13:09:26
+C Update\sthe\srest\sof\sthe\smalloc\sfailure\stest\sscripts\sto\suse\sthe\snew\sinterface.\s(CVS\s4296)
+D 2007-08-25T13:37:49
F Makefile.in 938f2769921fa1b30c633548f153804021eb1512
F Makefile.linux-gcc 65241babba6faf1152bf86574477baab19190499
F README 9c4e2d6706bdcc3efdd773ce752a8cdab4f90028
F src/test5.c 3a6a5717a149d7ca2e6d14f5be72cf7555d54dc4
F src/test6.c a6223d9d938aba83f20611a2c01680d8043cd2f7
F src/test7.c a9d509d0e9ad214b4772696f49f6e61be26213d1
-F src/test8.c e6a543c8b248efe120ae33a6859fcd55dcf46a96
+F src/test8.c a91b8d28341bbd168f5ba1ecad2be1008ddf15d1
F src/test9.c b46c8fe02ac7cca1a7316436d8d38d50c66f4b2f
F src/test_async.c 12ff3db0e052f561596d4dbdd29272f28b25060d
F src/test_autoext.c 855157d97aa28cf84233847548bfacda21807436
F test/attach.test cf289abdb120053136649efd1306ab9d47fa41b2
F test/attach2.test 78bc1a25ea8785c7571b44f5947ada2bd5d78127
F test/attach3.test eafcafb107585aecc2ed1569a77914138eef46a9
-F test/attachmalloc.test 03eeddd06e685ddbe975efd51824e4941847e5f4
+F test/attachmalloc.test c558251bcc3a2408d11fca42b9cee574fa3d74c2
F test/auth.test 66923137cf78475f5671b5e6e6274935e055aea0
F test/auth2.test 8da06f0ffcfd98154dda78e0f3b35a6503c27b64
F test/autoinc.test 60005a676e3e4e17dfa9dbd08aa0b76587ff97e3
F test/busy.test 0271c854738e23ad76e10d4096a698e5af29d211
F test/cache.test 3ff445c445742a7b6b9ba6e1d62a25263f9424b9
F test/capi2.test 3c5066836cbaa9923bcc8282c010aa227bb5efd4
-F test/capi3.test b436e762c01a9cb2235d4de8b55af3b887f0e384
+F test/capi3.test e1b40aa127de9ecfcca707f359d68b993ef38b4c
F test/capi3b.test 664eb55318132f292f2c436f90906f578cad6b97
-F test/capi3c.test 76a3fb94755288a2977ee387e95305e6224c0198
+F test/capi3c.test 787ce050fd5e09e419c920f91c7f404e62e20cd8
F test/cast.test c4780b58b569bab4947458195410ae8791ac216b
F test/check.test 024ed399600b799160378cf9d9f436bdf5dfd184
F test/collate1.test e3eaa48c21e150814be1a7b852d2a8af24458d04
F test/fuzz.test 62fc19dd36a427777fd671b569df07166548628a
F test/fuzz2.test ea38692ce2da99ad79fe0be5eb1a452c1c4d37bb
F test/fuzz_common.tcl ff4bc2dfc465f6878f8e2d819620914365382731
-F test/fuzz_malloc.test e2f1e74127ad7ab8fbeacc0f16d059a81c8f3ea6
+F test/fuzz_malloc.test 18f1502b2d926b47dba90728f1573928abd96a80
F test/hook.test 7e7645fd9a033f79cce8fdff151e32715e7ec50a
F test/icu.test e6bfae7f625c88fd14df6f540fe835bdfc1e4329
F test/in.test 369cb2aa1eab02296b4ec470732fe8c131260b1d
F test/shared.test 08b30d5f1939efff0517e7ff8ec7b74ad31c151b
F test/shared2.test 0ee9de8964d70e451936a48c41cb161d9134ccf4
F test/shared3.test 01e3e124dbb3859788aabc7cfb82f7ea04421749
-F test/shared_err.test cc528f6e78665787e93d9ce3a782a2ce5179d821
+F test/shared_err.test 9fa070e3e7d63022a81b6156ac71f114c0678e3d
F test/soak.test 64f9b27fbcdec43335a88c546ce1983e6ba40d7b
F test/softheap1.test 0c49aa6eee25e7d32943e85e8d1f20eff566b1dc
F test/sort.test 0e4456e729e5a92a625907c63dcdedfbe72c5dc5
F test/vtab9.test ea58d2b95d61955f87226381716b2d0b1d4e4f9b
F test/vtabA.test 9cb6b1afead6fdd91bbdf1ca65c44ccfd9b10936
F test/vtab_alter.test 87617789086fd1767aa071e7805f1af7e1dac144
-F test/vtab_err.test 9eabf98b26838fed8bac4aea986580be0a2bd52e
+F test/vtab_err.test f63f4c96bcd403076d49393136fb4fd9e0c5b402
F test/vtab_shared.test d631d1f820c38c18939d53aab1fc35db5f0a8094
F test/where.test 1bcde8984c63747ac6d6bafcacd20fd6e8a223de
F test/where2.test 3249d426b3fc7a106713d784e1628307fc308d2e
F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0
F www/version3.tcl 890248cf7b70e60c383b0e84d77d5132b3ead42b
F www/whentouse.tcl fc46eae081251c3c181bd79c5faef8195d7991a5
-P 686fcfeda407c29cdb51fe814da616f1ccac5414
-R 79030448b310160e2ed68e6b77c89fcc
+P e5ec17071720a973bbd213a8b23038d3aff25315
+R a2a459ce4d89b3260dd62868dc774bc5
U danielk1977
-Z f916d879cdbedc415720abb0ce0c3ff1
+Z 07d9ea0b58d791968ed1c4e04f1541a3
-e5ec17071720a973bbd213a8b23038d3aff25315
\ No newline at end of file
+b076e1655d6bae5ae10e6ceee646f502435da66a
\ No newline at end of file
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
-** $Id: test8.c,v 1.53 2007/08/23 02:47:53 drh Exp $
+** $Id: test8.c,v 1.54 2007/08/25 13:37:49 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "tcl.h"
if( pVtab->zTableName ){
sqlite3_stmt *pStmt = 0;
- sqlite3_prepare(db,
+ rc = sqlite3_prepare(db,
"SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
-1, &pStmt, 0);
- sqlite3_bind_text(pStmt, 1, pVtab->zTableName, -1, 0);
- if( sqlite3_step(pStmt)==SQLITE_ROW ){
- int rc2;
- const char *zCreateTable = (const char *)sqlite3_column_text(pStmt, 0);
- rc = sqlite3_declare_vtab(db, zCreateTable);
- rc2 = sqlite3_finalize(pStmt);
+ if( rc==SQLITE_OK ){
+ sqlite3_bind_text(pStmt, 1, pVtab->zTableName, -1, 0);
+ if( sqlite3_step(pStmt)==SQLITE_ROW ){
+ int rc2;
+ const char *zCreateTable = (const char *)sqlite3_column_text(pStmt, 0);
+ rc = sqlite3_declare_vtab(db, zCreateTable);
+ rc2 = sqlite3_finalize(pStmt);
+ if( rc==SQLITE_OK ){
+ rc = rc2;
+ }
+ } else {
+ rc = sqlite3_finalize(pStmt);
+ if( rc==SQLITE_OK ){
+ rc = SQLITE_ERROR;
+ }
+ }
if( rc==SQLITE_OK ){
- rc = rc2;
+ rc = getColumnNames(db, pVtab->zTableName, &pVtab->aCol, &pVtab->nCol);
}
- } else {
- rc = sqlite3_finalize(pStmt);
- if( rc==SQLITE_OK ){
- rc = SQLITE_ERROR;
+ if( rc==SQLITE_OK ){
+ rc = getIndexArray(db, pVtab->zTableName, pVtab->nCol, &pVtab->aIndex);
}
}
- if( rc==SQLITE_OK ){
- rc = getColumnNames(db, pVtab->zTableName, &pVtab->aCol, &pVtab->nCol);
- }
- if( rc==SQLITE_OK ){
- rc = getIndexArray(db, pVtab->zTableName, pVtab->nCol, &pVtab->aIndex);
- }
}
return rc;
appendToEchoModule(pVtab->interp, "xBestIndex");;
appendToEchoModule(pVtab->interp, zQuery);
+ if( !zQuery ){
+ return SQLITE_NOMEM;
+ }
pIdxInfo->idxNum = hashString(zQuery);
pIdxInfo->idxStr = zQuery;
pIdxInfo->needToFreeIdxStr = 1;
# focus of this script is testing the ATTACH statement and
# specifically out-of-memory conditions within that command.
#
-# $Id: attachmalloc.test,v 1.3 2006/09/04 18:54:14 drh Exp $
+# $Id: attachmalloc.test,v 1.4 2007/08/25 13:37:49 danielk1977 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
-}
-
-
-# Usage: do_malloc_test <test name> <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 set ::mallocopts $args
-
- set ::go 1
- for {set ::n 1} {$::go} {incr ::n} {
-
- do_test $tn.$::n {
-
- 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}
- set ::DB [sqlite3 db test.db]
-
- if {[info exists ::mallocopts(-tclprep)]} {
- eval $::mallocopts(-tclprep)
- }
- if {[info exists ::mallocopts(-sqlprep)]} {
- execsql $::mallocopts(-sqlprep)
- }
-
- 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]
-
- set leftover [lindex [sqlite_malloc_stat] 2]
- if {$leftover>0} {
- if {$leftover>1} {puts "\nLeftover: $leftover\nReturn=$v Message=$msg"}
- set ::go 0
- 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}
- sqlite_malloc_fail 0
-
- if {[info exists ::mallocopts(-cleanup)]} {
- catch $::mallocopts(-cleanup)
- }
- }
- unset ::mallocopts
-}
+source $testdir/malloc_common.tcl
do_malloc_test attachmalloc-1 -tclprep {
db close
# This file implements regression tests for SQLite library. The
# focus of this script testing the callback-free C/C++ API.
#
-# $Id: capi3.test,v 1.52 2007/08/22 02:56:44 drh Exp $
+# $Id: capi3.test,v 1.53 2007/08/25 13:37:49 danielk1977 Exp $
#
set testdir [file dirname $argv0]
}
# Test the error message when a "real" out of memory occurs.
-if {[info command sqlite_malloc_stat]!=""} {
-set sqlite_malloc_fail 1
-do_test capi3-10-1 {
- sqlite3 db test.db
- set DB [sqlite3_connection_pointer db]
- sqlite_malloc_fail 1
- catchsql {
- select * from sqlite_master;
- }
-} {1 {out of memory}}
-do_test capi3-10-2 {
- sqlite3_errmsg $::DB
-} {out of memory}
-ifcapable {utf16} {
- do_test capi3-10-3 {
- utf8 [sqlite3_errmsg16 $::DB]
+if {[info command sqlite3_memdebug_fail]!=""} {
+ do_test capi3-10-1 {
+ sqlite3 db test.db
+ set DB [sqlite3_connection_pointer db]
+ sqlite3_memdebug_fail 0 0
+ catchsql {
+ select * from sqlite_master;
+ }
+ } {1 {out of memory}}
+ do_test capi3-10-2 {
+ sqlite3_errmsg $::DB
} {out of memory}
-}
-db close
-sqlite_malloc_fail 0
+ ifcapable {utf16} {
+ do_test capi3-10-3 {
+ utf8 [sqlite3_errmsg16 $::DB]
+ } {out of memory}
+ }
+ db close
+ sqlite3_memdebug_fail -1 0
}
# The following tests - capi3-11.* - test that a COMMIT or ROLLBACK
# This is a copy of the capi3.test file that has been adapted to
# test the new sqlite3_prepare_v2 interface.
#
-# $Id: capi3c.test,v 1.9 2007/07/19 22:30:19 drh Exp $
+# $Id: capi3c.test,v 1.10 2007/08/25 13:37:49 danielk1977 Exp $
#
set testdir [file dirname $argv0]
}
# Test the error message when a "real" out of memory occurs.
-if {[info command sqlite_malloc_stat]!=""} {
-set sqlite_malloc_fail 1
-do_test capi3c-10-1 {
- sqlite3 db test.db
- set DB [sqlite3_connection_pointer db]
- sqlite_malloc_fail 1
- catchsql {
- select * from sqlite_master;
- }
-} {1 {out of memory}}
-do_test capi3c-10-2 {
- sqlite3_errmsg $::DB
-} {out of memory}
-ifcapable {utf16} {
- do_test capi3c-10-3 {
- utf8 [sqlite3_errmsg16 $::DB]
+if {[info command sqlite3_memdebug_fail]!=""} {
+ do_test capi3c-10-1 {
+ sqlite3 db test.db
+ set DB [sqlite3_connection_pointer db]
+ sqlite3_memdebug_fail 0 0
+ catchsql {
+ select * from sqlite_master;
+ }
+ } {1 {out of memory}}
+ do_test capi3c-10-2 {
+ sqlite3_errmsg $::DB
} {out of memory}
-}
-db close
-sqlite_malloc_fail 0
+ ifcapable {utf16} {
+ do_test capi3c-10-3 {
+ utf8 [sqlite3_errmsg16 $::DB]
+ } {out of memory}
+ }
+ db close
+ sqlite3_memdebug_fail -1 0
}
# The following tests - capi3c-11.* - test that a COMMIT or ROLLBACK
#
# This file tests malloc failures in concert with fuzzy SQL generation.
#
-# $Id: fuzz_malloc.test,v 1.5 2007/06/18 12:22:43 drh Exp $
+# $Id: fuzz_malloc.test,v 1.6 2007/08/25 13:37:49 danielk1977 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 fuzz_malloc tests: not compiled with -DSQLITE_MEMDEBUG=1"
- finish_test
- return
-}
-
-source $testdir/fuzz_common.tcl
source $testdir/malloc_common.tcl
+source $testdir/fuzz_common.tcl
if {[info exists ISQUICK]} {
set ::REPEATS 20
set ::fuzzyopts(-sqlprep) {}
array set ::fuzzyopts $args
- sqlite_malloc_fail 0
+ sqlite3_memdebug_fail -1 0
db close
file delete test.db test.db-journal
sqlite3 db test.db
-template {[Select]} \
-sqlprep $::SQLPREP
-sqlite_malloc_fail 0
+sqlite3_memdebug_fail -1 0
finish_test
# cache context. What happens to connection B if one connection A encounters
# an IO-error whilst reading or writing the file-system?
#
-# $Id: shared_err.test,v 1.11 2007/04/06 01:04:40 drh Exp $
+# $Id: shared_err.test,v 1.12 2007/08/25 13:37:49 danielk1977 Exp $
proc skip {args} {}
set testdir [file dirname $argv0]
source $testdir/tester.tcl
+source $testdir/malloc_common.tcl
db close
ifcapable !shared_cache||!subquery {
finish_test
return
}
-set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
-
-# Todo: This is a copy of the [do_malloc_test] proc in malloc.test
-# It would be better if these were consolidated.
-
-# 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 shared_malloc-$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]
-
- 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}
-
- sqlite_malloc_fail 0
- if {[info exists ::mallocopts(-cleanup)]} {
- catch [list uplevel #0 $::mallocopts(-cleanup)] msg
- }
- }
- unset ::mallocopts
-}
+set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
do_ioerr_test shared_ioerr-1 -tclprep {
sqlite3 db2 test.db
#
#***********************************************************************
#
-# $Id: vtab_err.test,v 1.5 2007/04/19 11:09:02 danielk1977 Exp $
+# $Id: vtab_err.test,v 1.6 2007/08/25 13:37:49 danielk1977 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 vtab_err tests: not compiled with -DSQLITE_MEMDEBUG=1"
- finish_test
- return
-}
+source $testdir/malloc_common.tcl
ifcapable !vtab {
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 $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)]} {
- if {[db errorcode]!=7 && $msg!="vtable constructor failed: e"} {
- 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" ||
- $msg == "vtable constructor failed: e"
- }]
- 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
-}
-
unset -nocomplain echo_module_begin_fail
do_ioerr_test vtab_err-1 -tclprep {
register_echo_module [sqlite3_connection_pointer db]
COMMIT;
}
-sqlite_malloc_fail 0
+sqlite3_memdebug_fail -1 0
+
finish_test
projects / thirdparty / sqlite.git / commitdiff
