3 # The author disclaims copyright to this source code. In place of
4 # a legal notice, here is a blessing:
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.
10 #***********************************************************************
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.
15 # $Id: malloc4.test,v 1.10 2008/02/18 22:24:58 drh Exp $
17 #---------------------------------------------------------------------------
18 # NOTES ON EXPECTED BEHAVIOUR
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.
24 #---------------------------------------------------------------------------
26 set testdir [file dirname $argv0]
27 source $testdir/tester.tcl
28 source $testdir/malloc_common.tcl
30 # Only run these tests if memory debugging is turned on.
32 puts "Skipping malloc4 tests: not compiled with -DSQLITE_MEMDEBUG..."
42 proc do_stmt_test {id sql} {
45 for {set n 0} {$go} {incr n} {
46 set testid "malloc4-$id.$n"
48 # Prepare the statement
50 set ::STMT [sqlite3_prepare $::DB $sql -1 TAIL]
51 expr [string length $::STMT] > 0
54 # Set the Nth malloc() to fail.
55 sqlite3_memdebug_fail $n -repeat 0
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.
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
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.
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 == ""}
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 == ""}
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 == ""}
92 set ::mallocFailed [expr [sqlite3_memdebug_pending] < 0]
93 do_test ${testid}.2.4 {
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
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
106 set mf [sqlite3_memdebug_pending]
107 sqlite3_memdebug_fail -1
108 do_test ${testid}.3 {
111 sqlite3_memdebug_fail $mf
113 # Test for malloc() failures within _text() and _text16().
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 == ""}
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 == ""}
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 != "")}
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
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
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
159 set mallocFailedAfterStep [expr \
160 [sqlite3_memdebug_pending] < 0 && !$::mallocFailed
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.
167 do_test ${testid}.5 {
169 } [expr {$mallocFailedAfterStep ? "SQLITE_ERROR" : "SQLITE_DONE"}]
171 do_test ${testid}.6 {
172 sqlite3_finalize $::STMT
173 } [expr {$mallocFailedAfterStep ? "SQLITE_NOMEM" : "SQLITE_OK"}]
175 if {$::mallocFailed == 0 && $mallocFailedAfterStep == 0} {
176 sqlite3_memdebug_fail -1
184 the_first_reasonably_long_column_name that_also_has_quite_a_lengthy_type
186 INSERT INTO tbl VALUES(
187 'An extra long string. Far too long to be stored in NBFS bytes.'
191 do_stmt_test 1 "SELECT * FROM tbl"
193 sqlite3_memdebug_fail -1