# 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.3 2006/01/23 07:52:41 danielk1977 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# 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..."   finish_test   return}ifcapable !utf16 {  finish_test  return}proc do_stmt_test {id sql} {  set ::sql $sql  set go 1  for {set n 1} {$go} {incr n} {    set testid "malloc4-$id.(iFail $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.    sqlite_malloc_fail $n    # 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 [lindex [sqlite_malloc_stat] 2] <= 0]      set ::name8  [sqlite3_column_name $::STMT 0]      set mf2 [expr [lindex [sqlite_malloc_stat] 2] <= 0]      expr {$mf1 == $mf2 || $::name8 == ""}    } {1}    do_test ${testid}.2.2 {      set mf1 [expr [lindex [sqlite_malloc_stat] 2] <= 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]      expr {$mf1 == $mf2 || $::name16 == ""}    } {1}    do_test ${testid}.2.3 {      set mf1 [expr [lindex [sqlite_malloc_stat] 2] <= 0]      set ::name8_2 [sqlite3_column_name $::STMT 0]      set mf2 [expr [lindex [sqlite_malloc_stat] 2] <= 0]      expr {$mf1 == $mf2 || $::name8_2 == ""}    } {1}    set ::mallocFailed [expr [lindex [sqlite_malloc_stat] 2] <= 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 [lindex [sqlite_malloc_stat] 2]    sqlite_malloc_fail 0    do_test ${testid}.3 {      sqlite3_step $::STMT    } {SQLITE_ROW}    sqlite_malloc_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]      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]      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]      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 [lindex [sqlite_malloc_stat] 2]      sqlite_malloc_fail 0      sqlite3_column_text16 $::STMT 0      sqlite_malloc_fail $mf      sqlite3_column_int $::STMT 0    } {0}    do_test ${testid}.4.5 {      set mf [lindex [sqlite_malloc_stat] 2]      sqlite_malloc_fail 0      sqlite3_column_text16 $::STMT 0      sqlite_malloc_fail $mf      sqlite3_column_int64 $::STMT 0    } {0}    do_test ${testid}.4.6 {      set mf [lindex [sqlite_malloc_stat] 2]      sqlite_malloc_fail 0      sqlite3_column_text16 $::STMT 0      sqlite_malloc_fail $mf      sqlite3_column_double $::STMT 0    } {0.0}    set mallocFailedAfterStep [expr \      [lindex [sqlite_malloc_stat] 2] <= 0 && !$::mallocFailed    ]    sqlite_malloc_fail 0    # 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} {      sqlite_malloc_fail 0      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"sqlite_malloc_fail 0finish_test