xref: /sqlite-3.40.0/test/malloc4.test (revision cb6acda9) 
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
26set testdir [file dirname $argv0]
27source $testdir/tester.tcl
28source $testdir/malloc_common.tcl
29
30# Only run these tests if memory debugging is turned on.
31if {!$MEMDEBUG} {
32   puts "Skipping malloc4 tests: not compiled with -DSQLITE_MEMDEBUG..."
33   finish_test
34   return
35}
36
37ifcapable !utf16 {
38  finish_test
39  return
40}
41
42proc 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
182execsql {
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
191do_stmt_test 1 "SELECT * FROM tbl"
192
193sqlite3_memdebug_fail -1
194finish_test
195