Annotation of embedaddon/sqlite3/test/malloc4.test, revision 1.1
1.1 ! misho 1: # 2005 November 30
! 2: #
! 3: # The author disclaims copyright to this source code. In place of
! 4: # a legal notice, here is a blessing:
! 5: #
! 6: # May you do good and not evil.
! 7: # May you find forgiveness for yourself and forgive others.
! 8: # May you share freely, never taking more than you give.
! 9: #
! 10: #***********************************************************************
! 11: #
! 12: # This file contains tests to ensure that the library handles malloc() failures
! 13: # correctly. The emphasis in this file is on sqlite3_column_XXX() APIs.
! 14: #
! 15: # $Id: malloc4.test,v 1.10 2008/02/18 22:24:58 drh Exp $
! 16:
! 17: #---------------------------------------------------------------------------
! 18: # NOTES ON EXPECTED BEHAVIOUR
! 19: #
! 20: # [193] When a memory allocation failure occurs during sqlite3_column_name(),
! 21: # sqlite3_column_name16(), sqlite3_column_decltype(), or
! 22: # sqlite3_column_decltype16() the function shall return NULL.
! 23: #
! 24: #---------------------------------------------------------------------------
! 25:
! 26: set testdir [file dirname $argv0]
! 27: source $testdir/tester.tcl
! 28: source $testdir/malloc_common.tcl
! 29:
! 30: # Only run these tests if memory debugging is turned on.
! 31: if {!$MEMDEBUG} {
! 32: puts "Skipping malloc4 tests: not compiled with -DSQLITE_MEMDEBUG..."
! 33: finish_test
! 34: return
! 35: }
! 36:
! 37: ifcapable !utf16 {
! 38: finish_test
! 39: return
! 40: }
! 41:
! 42: proc do_stmt_test {id sql} {
! 43: set ::sql $sql
! 44: set go 1
! 45: for {set n 0} {$go} {incr n} {
! 46: set testid "malloc4-$id.$n"
! 47:
! 48: # Prepare the statement
! 49: do_test ${testid}.1 {
! 50: set ::STMT [sqlite3_prepare $::DB $sql -1 TAIL]
! 51: expr [string length $::STMT] > 0
! 52: } {1}
! 53:
! 54: # Set the Nth malloc() to fail.
! 55: sqlite3_memdebug_fail $n -repeat 0
! 56:
! 57: # Test malloc failure in the _name(), _name16(), decltype() and
! 58: # decltype16() APIs. Calls that occur after the malloc() failure should
! 59: # return NULL. No error is raised though.
! 60: #
! 61: # ${testid}.2.1 - Call _name()
! 62: # ${testid}.2.2 - Call _name16()
! 63: # ${testid}.2.3 - Call _name()
! 64: # ${testid}.2.4 - Check that the return values of the above three calls are
! 65: # consistent with each other and with the simulated
! 66: # malloc() failures.
! 67: #
! 68: # Because the code that implements the _decltype() and _decltype16() APIs
! 69: # is the same as the _name() and _name16() implementations, we don't worry
! 70: # about explicitly testing them.
! 71: #
! 72: do_test ${testid}.2.1 {
! 73: set mf1 [expr [sqlite3_memdebug_pending] < 0]
! 74: set ::name8 [sqlite3_column_name $::STMT 0]
! 75: set mf2 [expr [sqlite3_memdebug_pending] < 0]
! 76: expr {$mf1 == $mf2 || $::name8 == ""}
! 77: } {1}
! 78: do_test ${testid}.2.2 {
! 79: set mf1 [expr [sqlite3_memdebug_pending] < 0]
! 80: set ::name16 [sqlite3_column_name16 $::STMT 0]
! 81: set ::name16 [encoding convertfrom unicode $::name16]
! 82: set ::name16 [string range $::name16 0 end-1]
! 83: set mf2 [expr [sqlite3_memdebug_pending] < 0]
! 84: expr {$mf1 == $mf2 || $::name16 == ""}
! 85: } {1}
! 86: do_test ${testid}.2.3 {
! 87: set mf1 [expr [sqlite3_memdebug_pending] < 0]
! 88: set ::name8_2 [sqlite3_column_name $::STMT 0]
! 89: set mf2 [expr [sqlite3_memdebug_pending] < 0]
! 90: expr {$mf1 == $mf2 || $::name8_2 == ""}
! 91: } {1}
! 92: set ::mallocFailed [expr [sqlite3_memdebug_pending] < 0]
! 93: do_test ${testid}.2.4 {
! 94: expr {
! 95: $::name8 == $::name8_2 && $::name16 == $::name8 && !$::mallocFailed ||
! 96: $::name8 == $::name8_2 && $::name16 == "" && $::mallocFailed ||
! 97: $::name8 == $::name16 && $::name8_2 == "" && $::mallocFailed ||
! 98: $::name8_2 == $::name16 && $::name8 == "" && $::mallocFailed
! 99: }
! 100: } {1}
! 101:
! 102: # Step the statement so that we can call _text() and _text16(). Before
! 103: # running sqlite3_step(), make sure that malloc() is not about to fail.
! 104: # Memory allocation failures that occur within sqlite3_step() are tested
! 105: # elsewhere.
! 106: set mf [sqlite3_memdebug_pending]
! 107: sqlite3_memdebug_fail -1
! 108: do_test ${testid}.3 {
! 109: sqlite3_step $::STMT
! 110: } {SQLITE_ROW}
! 111: sqlite3_memdebug_fail $mf
! 112:
! 113: # Test for malloc() failures within _text() and _text16().
! 114: #
! 115: do_test ${testid}.4.1 {
! 116: set ::text8 [sqlite3_column_text $::STMT 0]
! 117: set mf [expr [sqlite3_memdebug_pending] < 0 && !$::mallocFailed]
! 118: expr {$mf==0 || $::text8 == ""}
! 119: } {1}
! 120: do_test ${testid}.4.2 {
! 121: set ::text16 [sqlite3_column_text16 $::STMT 0]
! 122: set ::text16 [encoding convertfrom unicode $::text16]
! 123: set ::text16 [string range $::text16 0 end-1]
! 124: set mf [expr [sqlite3_memdebug_pending] < 0 && !$::mallocFailed]
! 125: expr {$mf==0 || $::text16 == ""}
! 126: } {1}
! 127: do_test ${testid}.4.3 {
! 128: set ::text8_2 [sqlite3_column_text $::STMT 0]
! 129: set mf [expr [sqlite3_memdebug_pending] < 0 && !$::mallocFailed]
! 130: expr {$mf==0 || $::text8_2 == "" || ($::text16 == "" && $::text8 != "")}
! 131: } {1}
! 132:
! 133: # Test for malloc() failures within _int(), _int64() and _real(). The only
! 134: # way this can occur is if the string has to be translated from UTF-16 to
! 135: # UTF-8 before being converted to a numeric value.
! 136: do_test ${testid}.4.4.1 {
! 137: set mf [sqlite3_memdebug_pending]
! 138: sqlite3_memdebug_fail -1
! 139: sqlite3_column_text16 $::STMT 0
! 140: sqlite3_memdebug_fail $mf
! 141: sqlite3_column_int $::STMT 0
! 142: } {0}
! 143: do_test ${testid}.4.5 {
! 144: set mf [sqlite3_memdebug_pending]
! 145: sqlite3_memdebug_fail -1
! 146: sqlite3_column_text16 $::STMT 0
! 147: sqlite3_memdebug_fail $mf
! 148: sqlite3_column_int64 $::STMT 0
! 149: } {0}
! 150:
! 151: do_test ${testid}.4.6 {
! 152: set mf [sqlite3_memdebug_pending]
! 153: sqlite3_memdebug_fail -1
! 154: sqlite3_column_text16 $::STMT 0
! 155: sqlite3_memdebug_fail $mf
! 156: sqlite3_column_double $::STMT 0
! 157: } {0.0}
! 158:
! 159: set mallocFailedAfterStep [expr \
! 160: [sqlite3_memdebug_pending] < 0 && !$::mallocFailed
! 161: ]
! 162:
! 163: sqlite3_memdebug_fail -1
! 164: # Test that if a malloc() failed the next call to sqlite3_step() returns
! 165: # SQLITE_ERROR. If malloc() did not fail, it should return SQLITE_DONE.
! 166: #
! 167: do_test ${testid}.5 {
! 168: sqlite3_step $::STMT
! 169: } [expr {$mallocFailedAfterStep ? "SQLITE_ERROR" : "SQLITE_DONE"}]
! 170:
! 171: do_test ${testid}.6 {
! 172: sqlite3_finalize $::STMT
! 173: } [expr {$mallocFailedAfterStep ? "SQLITE_NOMEM" : "SQLITE_OK"}]
! 174:
! 175: if {$::mallocFailed == 0 && $mallocFailedAfterStep == 0} {
! 176: sqlite3_memdebug_fail -1
! 177: set go 0
! 178: }
! 179: }
! 180: }
! 181:
! 182: execsql {
! 183: CREATE TABLE tbl(
! 184: the_first_reasonably_long_column_name that_also_has_quite_a_lengthy_type
! 185: );
! 186: INSERT INTO tbl VALUES(
! 187: 'An extra long string. Far too long to be stored in NBFS bytes.'
! 188: );
! 189: }
! 190:
! 191: do_stmt_test 1 "SELECT * FROM tbl"
! 192:
! 193: sqlite3_memdebug_fail -1
! 194: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to malloc4.test CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test