diff options
Diffstat (limited to '')
| -rw-r--r-- | test/malloc4.test | 194 |
1 files changed, 194 insertions, 0 deletions
diff --git a/test/malloc4.test b/test/malloc4.test new file mode 100644 index 0000000..e2a616a --- /dev/null +++ b/test/malloc4.test @@ -0,0 +1,194 @@ +# 2005 November 30 +# +# The author disclaims copyright to this source code. In place of +# a legal notice, here is a blessing: +# +# May you do good and not evil. +# May you find forgiveness for yourself and forgive others. +# May you share freely, never taking more than you give. +# +#*********************************************************************** +# +# 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.10 2008/02/18 22:24:58 drh Exp $ + +#--------------------------------------------------------------------------- +# NOTES ON EXPECTED BEHAVIOUR +# +# [193] When a memory allocation failure occurs during sqlite3_column_name(), +# sqlite3_column_name16(), sqlite3_column_decltype(), or +# sqlite3_column_decltype16() the function shall return NULL. +# +#--------------------------------------------------------------------------- + +set testdir [file dirname $argv0] +source $testdir/tester.tcl +source $testdir/malloc_common.tcl + +# Only run these tests if memory debugging is turned on. +if {!$MEMDEBUG} { + puts "Skipping malloc4 tests: not compiled with -DSQLITE_MEMDEBUG..." + finish_test + return +} + +ifcapable !utf16 { + finish_test + return +} + +proc do_stmt_test {id sql} { + set ::sql $sql + set go 1 + for {set n 0} {$go} {incr n} { + set testid "malloc4-$id.$n" + + # Prepare the statement + do_test ${testid}.1 { + set ::STMT [sqlite3_prepare $::DB $sql -1 TAIL] + expr [string length $::STMT] > 0 + } {1} + + # Set the Nth malloc() to fail. + sqlite3_memdebug_fail $n -repeat 0 + + # Test malloc failure in the _name(), _name16(), decltype() and + # decltype16() APIs. Calls that occur after the malloc() failure should + # return NULL. No error is raised though. + # + # ${testid}.2.1 - Call _name() + # ${testid}.2.2 - Call _name16() + # ${testid}.2.3 - Call _name() + # ${testid}.2.4 - Check that the return values of the above three calls are + # consistent with each other and with the simulated + # malloc() failures. + # + # Because the code that implements the _decltype() and _decltype16() APIs + # is the same as the _name() and _name16() implementations, we don't worry + # about explicitly testing them. + # + do_test ${testid}.2.1 { + set mf1 [expr [sqlite3_memdebug_pending] < 0] + set ::name8 [sqlite3_column_name $::STMT 0] + set mf2 [expr [sqlite3_memdebug_pending] < 0] + expr {$mf1 == $mf2 || $::name8 == ""} + } {1} + do_test ${testid}.2.2 { + 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 [sqlite3_memdebug_pending] < 0] + expr {$mf1 == $mf2 || $::name16 == ""} + } {1} + do_test ${testid}.2.3 { + set mf1 [expr [sqlite3_memdebug_pending] < 0] + set ::name8_2 [sqlite3_column_name $::STMT 0] + set mf2 [expr [sqlite3_memdebug_pending] < 0] + expr {$mf1 == $mf2 || $::name8_2 == ""} + } {1} + set ::mallocFailed [expr [sqlite3_memdebug_pending] < 0] + do_test ${testid}.2.4 { + expr { + $::name8 == $::name8_2 && $::name16 == $::name8 && !$::mallocFailed || + $::name8 == $::name8_2 && $::name16 == "" && $::mallocFailed || + $::name8 == $::name16 && $::name8_2 == "" && $::mallocFailed || + $::name8_2 == $::name16 && $::name8 == "" && $::mallocFailed + } + } {1} + + # Step the statement so that we can call _text() and _text16(). Before + # 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 [sqlite3_memdebug_pending] + sqlite3_memdebug_fail -1 + do_test ${testid}.3 { + sqlite3_step $::STMT + } {SQLITE_ROW} + 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 [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 [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 [sqlite3_memdebug_pending] < 0 && !$::mallocFailed] + expr {$mf==0 || $::text8_2 == "" || ($::text16 == "" && $::text8 != "")} + } {1} + + # Test for malloc() failures within _int(), _int64() and _real(). The only + # 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 [sqlite3_memdebug_pending] + sqlite3_memdebug_fail -1 + sqlite3_column_text16 $::STMT 0 + sqlite3_memdebug_fail $mf + sqlite3_column_int $::STMT 0 + } {0} + do_test ${testid}.4.5 { + set mf [sqlite3_memdebug_pending] + sqlite3_memdebug_fail -1 + sqlite3_column_text16 $::STMT 0 + sqlite3_memdebug_fail $mf + sqlite3_column_int64 $::STMT 0 + } {0} + + do_test ${testid}.4.6 { + set mf [sqlite3_memdebug_pending] + sqlite3_memdebug_fail -1 + sqlite3_column_text16 $::STMT 0 + sqlite3_memdebug_fail $mf + sqlite3_column_double $::STMT 0 + } {0.0} + + set mallocFailedAfterStep [expr \ + [sqlite3_memdebug_pending] < 0 && !$::mallocFailed + ] + + 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. + # + do_test ${testid}.5 { + sqlite3_step $::STMT + } [expr {$mallocFailedAfterStep ? "SQLITE_ERROR" : "SQLITE_DONE"}] + + do_test ${testid}.6 { + sqlite3_finalize $::STMT + } [expr {$mallocFailedAfterStep ? "SQLITE_NOMEM" : "SQLITE_OK"}] + + if {$::mallocFailed == 0 && $mallocFailedAfterStep == 0} { + sqlite3_memdebug_fail -1 + set go 0 + } + } +} + +execsql { + CREATE TABLE tbl( + the_first_reasonably_long_column_name that_also_has_quite_a_lengthy_type + ); + INSERT INTO tbl VALUES( + 'An extra long string. Far too long to be stored in NBFS bytes.' + ); +} + +do_stmt_test 1 "SELECT * FROM tbl" + +sqlite3_memdebug_fail -1 +finish_test |