| # 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 |
