1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
# 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.10 2008/02/18 22:24:58 drh 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
source $testdir/malloc_common.tcl
# Only run these tests if memory debugging is turned on.
if {!$MEMDEBUG} {
puts "Skipping malloc4 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 0} {$go} {incr n} {
set testid "malloc4-$id.$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.
sqlite3_memdebug_fail $n -repeat 0
# 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 [sqlite3_memdebug_pending] < 0]
set ::name8 [sqlite3_column_name $::STMT 0]
set mf2 [expr [sqlite3_memdebug_pending] < 0]
expr {$mf1 == $mf2 || $::name8 == ""}
} {1}
do_test ${testid}.2.2 {
set mf1 [expr [sqlite3_memdebug_pending] < 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 [sqlite3_memdebug_pending] < 0]
expr {$mf1 == $mf2 || $::name16 == ""}
} {1}
do_test ${testid}.2.3 {
set mf1 [expr [sqlite3_memdebug_pending] < 0]
set ::name8_2 [sqlite3_column_name $::STMT 0]
set mf2 [expr [sqlite3_memdebug_pending] < 0]
expr {$mf1 == $mf2 || $::name8_2 == ""}
} {1}
set ::mallocFailed [expr [sqlite3_memdebug_pending] < 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 [sqlite3_memdebug_pending]
sqlite3_memdebug_fail -1
do_test ${testid}.3 {
sqlite3_step $::STMT
} {SQLITE_ROW}
sqlite3_memdebug_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 [sqlite3_memdebug_pending] < 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 [sqlite3_memdebug_pending] < 0 && !$::mallocFailed]
expr {$mf==0 || $::text16 == ""}
} {1}
do_test ${testid}.4.3 {
set ::text8_2 [sqlite3_column_text $::STMT 0]
set mf [expr [sqlite3_memdebug_pending] < 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 [sqlite3_memdebug_pending]
sqlite3_memdebug_fail -1
sqlite3_column_text16 $::STMT 0
sqlite3_memdebug_fail $mf
sqlite3_column_int $::STMT 0
} {0}
do_test ${testid}.4.5 {
set mf [sqlite3_memdebug_pending]
sqlite3_memdebug_fail -1
sqlite3_column_text16 $::STMT 0
sqlite3_memdebug_fail $mf
sqlite3_column_int64 $::STMT 0
} {0}
do_test ${testid}.4.6 {
set mf [sqlite3_memdebug_pending]
sqlite3_memdebug_fail -1
sqlite3_column_text16 $::STMT 0
sqlite3_memdebug_fail $mf
sqlite3_column_double $::STMT 0
} {0.0}
set mallocFailedAfterStep [expr \
[sqlite3_memdebug_pending] < 0 && !$::mallocFailed
]
sqlite3_memdebug_fail -1
# 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} {
sqlite3_memdebug_fail -1
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"
sqlite3_memdebug_fail -1
finish_test
|
