xref: /sqlite-3.40.0/test/malloc4.test (revision 74e4352a) 
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.3 2006/01/23 07:52:41 danielk1977 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
28
29# Only run these tests if memory debugging is turned on.
30if {[info command sqlite_malloc_stat]==""} {
31   puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
32   finish_test
33   return
34}
35
36ifcapable !utf16 {
37  finish_test
38  return
39}
40
41proc do_stmt_test {id sql} {
42  set ::sql $sql
43  set go 1
44  for {set n 1} {$go} {incr n} {
45    set testid "malloc4-$id.(iFail $n)"
46
47    # Prepare the statement
48    do_test ${testid}.1 {
49      set ::STMT [sqlite3_prepare $::DB $sql -1 TAIL]
50      expr [string length $::STMT] > 0
51    } {1}
52
53    # Set the Nth malloc() to fail.
54    sqlite_malloc_fail $n
55
56    # Test malloc failure in the _name(), _name16(), decltype() and
57    # decltype16() APIs. Calls that occur after the malloc() failure should
58    # return NULL. No error is raised though.
59    #
60    # ${testid}.2.1 - Call _name()
61    # ${testid}.2.2 - Call _name16()
62    # ${testid}.2.3 - Call _name()
63    # ${testid}.2.4 - Check that the return values of the above three calls are
64    #                 consistent with each other and with the simulated
65    #                 malloc() failures.
66    #
67    # Because the code that implements the _decltype() and _decltype16() APIs
68    # is the same as the _name() and _name16() implementations, we don't worry
69    # about explicitly testing them.
70    #
71    do_test ${testid}.2.1 {
72      set mf1 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
73      set ::name8  [sqlite3_column_name $::STMT 0]
74      set mf2 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
75      expr {$mf1 == $mf2 || $::name8 == ""}
76    } {1}
77    do_test ${testid}.2.2 {
78      set mf1 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
79      set ::name16 [sqlite3_column_name16 $::STMT 0]
80      set ::name16 [encoding convertfrom unicode $::name16]
81      set ::name16 [string range $::name16 0 end-1]
82      set mf2 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
83      expr {$mf1 == $mf2 || $::name16 == ""}
84    } {1}
85    do_test ${testid}.2.3 {
86      set mf1 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
87      set ::name8_2 [sqlite3_column_name $::STMT 0]
88      set mf2 [expr [lindex [sqlite_malloc_stat] 2] <= 0]
89      expr {$mf1 == $mf2 || $::name8_2 == ""}
90    } {1}
91    set ::mallocFailed [expr [lindex [sqlite_malloc_stat] 2] <= 0]
92    do_test ${testid}.2.4 {
93      expr {
94        $::name8 == $::name8_2 && $::name16 == $::name8 && !$::mallocFailed ||
95        $::name8 == $::name8_2 && $::name16 == "" &&        $::mallocFailed ||
96        $::name8 == $::name16 && $::name8_2 == "" &&        $::mallocFailed ||
97        $::name8_2 == $::name16 && $::name8 == "" &&        $::mallocFailed
98      }
99    } {1}
100
101    # Step the statement so that we can call _text() and _text16().  Before
102    # running sqlite3_step(), make sure that malloc() is not about to fail.
103    # Memory allocation failures that occur within sqlite3_step() are tested
104    # elsewhere.
105    set mf [lindex [sqlite_malloc_stat] 2]
106    sqlite_malloc_fail 0
107    do_test ${testid}.3 {
108      sqlite3_step $::STMT
109    } {SQLITE_ROW}
110    sqlite_malloc_fail $mf
111
112    # Test for malloc() failures within _text() and _text16().
113    #
114    do_test ${testid}.4.1 {
115      set ::text8 [sqlite3_column_text $::STMT 0]
116      set mf [expr [lindex [sqlite_malloc_stat] 2] <= 0 && !$::mallocFailed]
117      expr {$mf==0 || $::text8 == ""}
118    } {1}
119    do_test ${testid}.4.2 {
120      set ::text16 [sqlite3_column_text16 $::STMT 0]
121      set ::text16 [encoding convertfrom unicode $::text16]
122      set ::text16 [string range $::text16 0 end-1]
123      set mf [expr [lindex [sqlite_malloc_stat] 2] <= 0 && !$::mallocFailed]
124      expr {$mf==0 || $::text16 == ""}
125    } {1}
126    do_test ${testid}.4.3 {
127      set ::text8_2 [sqlite3_column_text $::STMT 0]
128      set mf [expr [lindex [sqlite_malloc_stat] 2] <= 0 && !$::mallocFailed]
129      expr {$mf==0 || $::text8_2 == "" || ($::text16 == "" && $::text8 != "")}
130    } {1}
131
132    # Test for malloc() failures within _int(), _int64() and _real(). The only
133    # way this can occur is if the string has to be translated from UTF-16 to
134    # UTF-8 before being converted to a numeric value.
135    do_test ${testid}.4.4.1 {
136      set mf [lindex [sqlite_malloc_stat] 2]
137      sqlite_malloc_fail 0
138      sqlite3_column_text16 $::STMT 0
139      sqlite_malloc_fail $mf
140      sqlite3_column_int $::STMT 0
141    } {0}
142    do_test ${testid}.4.5 {
143      set mf [lindex [sqlite_malloc_stat] 2]
144      sqlite_malloc_fail 0
145      sqlite3_column_text16 $::STMT 0
146      sqlite_malloc_fail $mf
147      sqlite3_column_int64 $::STMT 0
148    } {0}
149
150    do_test ${testid}.4.6 {
151      set mf [lindex [sqlite_malloc_stat] 2]
152      sqlite_malloc_fail 0
153      sqlite3_column_text16 $::STMT 0
154      sqlite_malloc_fail $mf
155      sqlite3_column_double $::STMT 0
156    } {0.0}
157
158    set mallocFailedAfterStep [expr \
159      [lindex [sqlite_malloc_stat] 2] <= 0 && !$::mallocFailed
160    ]
161
162    sqlite_malloc_fail 0
163    # Test that if a malloc() failed the next call to sqlite3_step() returns
164    # SQLITE_ERROR. If malloc() did not fail, it should return SQLITE_DONE.
165    #
166    do_test ${testid}.5 {
167      sqlite3_step $::STMT
168    } [expr {$mallocFailedAfterStep ? "SQLITE_ERROR" : "SQLITE_DONE"}]
169
170    do_test ${testid}.6 {
171      sqlite3_finalize $::STMT
172    } [expr {$mallocFailedAfterStep ? "SQLITE_NOMEM" : "SQLITE_OK"}]
173
174    if {$::mallocFailed == 0 && $mallocFailedAfterStep == 0} {
175      sqlite_malloc_fail 0
176      set go 0
177    }
178  }
179}
180
181execsql {
182  CREATE TABLE tbl(
183    the_first_reasonably_long_column_name that_also_has_quite_a_lengthy_type
184  );
185  INSERT INTO tbl VALUES(
186    'An extra long string. Far too long to be stored in NBFS bytes.'
187  );
188}
189
190do_stmt_test 1 "SELECT * FROM tbl"
191
192sqlite_malloc_fail 0
193finish_test
194
195