1 // Copyright 2011 The Kyua Authors.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // * Neither the name of Google Inc. nor the names of its contributors
14 // may be used to endorse or promote products derived from this software
15 // without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29 #include "utils/sqlite/statement.ipp"
30
31 extern "C" {
32 #include <stdint.h>
33 }
34
35 #include <cstring>
36 #include <iostream>
37
38 #include <atf-c++.hpp>
39
40 #include "utils/sqlite/database.hpp"
41 #include "utils/sqlite/test_utils.hpp"
42
43 namespace sqlite = utils::sqlite;
44
45
46 ATF_TEST_CASE_WITHOUT_HEAD(step__ok);
ATF_TEST_CASE_BODY(step__ok)47 ATF_TEST_CASE_BODY(step__ok)
48 {
49 sqlite::database db = sqlite::database::in_memory();
50 sqlite::statement stmt = db.create_statement(
51 "CREATE TABLE foo (a INTEGER PRIMARY KEY)");
52 ATF_REQUIRE_THROW(sqlite::error, db.exec("SELECT * FROM foo"));
53 ATF_REQUIRE(!stmt.step());
54 db.exec("SELECT * FROM foo");
55 }
56
57
58 ATF_TEST_CASE_WITHOUT_HEAD(step__many);
ATF_TEST_CASE_BODY(step__many)59 ATF_TEST_CASE_BODY(step__many)
60 {
61 sqlite::database db = sqlite::database::in_memory();
62 create_test_table(raw(db));
63 sqlite::statement stmt = db.create_statement(
64 "SELECT prime FROM test ORDER BY prime");
65 for (int i = 0; i < 5; i++)
66 ATF_REQUIRE(stmt.step());
67 ATF_REQUIRE(!stmt.step());
68 }
69
70
71 ATF_TEST_CASE_WITHOUT_HEAD(step__fail);
ATF_TEST_CASE_BODY(step__fail)72 ATF_TEST_CASE_BODY(step__fail)
73 {
74 sqlite::database db = sqlite::database::in_memory();
75 sqlite::statement stmt = db.create_statement(
76 "CREATE TABLE foo (a INTEGER PRIMARY KEY)");
77 ATF_REQUIRE(!stmt.step());
78 REQUIRE_API_ERROR("sqlite3_step", stmt.step());
79 }
80
81
82 ATF_TEST_CASE_WITHOUT_HEAD(step_without_results__ok);
ATF_TEST_CASE_BODY(step_without_results__ok)83 ATF_TEST_CASE_BODY(step_without_results__ok)
84 {
85 sqlite::database db = sqlite::database::in_memory();
86 sqlite::statement stmt = db.create_statement(
87 "CREATE TABLE foo (a INTEGER PRIMARY KEY)");
88 ATF_REQUIRE_THROW(sqlite::error, db.exec("SELECT * FROM foo"));
89 stmt.step_without_results();
90 db.exec("SELECT * FROM foo");
91 }
92
93
94 ATF_TEST_CASE_WITHOUT_HEAD(step_without_results__fail);
ATF_TEST_CASE_BODY(step_without_results__fail)95 ATF_TEST_CASE_BODY(step_without_results__fail)
96 {
97 sqlite::database db = sqlite::database::in_memory();
98 db.exec("CREATE TABLE foo (a INTEGER PRIMARY KEY)");
99 db.exec("INSERT INTO foo VALUES (3)");
100 sqlite::statement stmt = db.create_statement(
101 "INSERT INTO foo VALUES (3)");
102 REQUIRE_API_ERROR("sqlite3_step", stmt.step_without_results());
103 }
104
105
106 ATF_TEST_CASE_WITHOUT_HEAD(column_count);
ATF_TEST_CASE_BODY(column_count)107 ATF_TEST_CASE_BODY(column_count)
108 {
109 sqlite::database db = sqlite::database::in_memory();
110 db.exec("CREATE TABLE foo (a INTEGER PRIMARY KEY, b INTEGER, c TEXT);"
111 "INSERT INTO foo VALUES (5, 3, 'foo');");
112 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
113 ATF_REQUIRE(stmt.step());
114 ATF_REQUIRE_EQ(3, stmt.column_count());
115 ATF_REQUIRE(!stmt.step());
116 }
117
118
119 ATF_TEST_CASE_WITHOUT_HEAD(column_name__ok);
ATF_TEST_CASE_BODY(column_name__ok)120 ATF_TEST_CASE_BODY(column_name__ok)
121 {
122 sqlite::database db = sqlite::database::in_memory();
123 db.exec("CREATE TABLE foo (first INTEGER PRIMARY KEY, second TEXT);"
124 "INSERT INTO foo VALUES (5, 'foo');");
125 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
126 ATF_REQUIRE(stmt.step());
127 ATF_REQUIRE_EQ("first", stmt.column_name(0));
128 ATF_REQUIRE_EQ("second", stmt.column_name(1));
129 ATF_REQUIRE(!stmt.step());
130 }
131
132
133 ATF_TEST_CASE_WITHOUT_HEAD(column_name__fail);
ATF_TEST_CASE_BODY(column_name__fail)134 ATF_TEST_CASE_BODY(column_name__fail)
135 {
136 sqlite::database db = sqlite::database::in_memory();
137 db.exec("CREATE TABLE foo (first INTEGER PRIMARY KEY);"
138 "INSERT INTO foo VALUES (5);");
139 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
140 ATF_REQUIRE(stmt.step());
141 ATF_REQUIRE_EQ("first", stmt.column_name(0));
142 REQUIRE_API_ERROR("sqlite3_column_name", stmt.column_name(1));
143 ATF_REQUIRE(!stmt.step());
144 }
145
146
147 ATF_TEST_CASE_WITHOUT_HEAD(column_type__ok);
ATF_TEST_CASE_BODY(column_type__ok)148 ATF_TEST_CASE_BODY(column_type__ok)
149 {
150 sqlite::database db = sqlite::database::in_memory();
151 db.exec("CREATE TABLE foo (a_blob BLOB,"
152 " a_float FLOAT,"
153 " an_integer INTEGER,"
154 " a_null BLOB,"
155 " a_text TEXT);"
156 "INSERT INTO foo VALUES (x'0102', 0.3, 5, NULL, 'foo bar');"
157 "INSERT INTO foo VALUES (NULL, NULL, NULL, NULL, NULL);");
158 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
159 ATF_REQUIRE(stmt.step());
160 ATF_REQUIRE(sqlite::type_blob == stmt.column_type(0));
161 ATF_REQUIRE(sqlite::type_float == stmt.column_type(1));
162 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(2));
163 ATF_REQUIRE(sqlite::type_null == stmt.column_type(3));
164 ATF_REQUIRE(sqlite::type_text == stmt.column_type(4));
165 ATF_REQUIRE(stmt.step());
166 for (int i = 0; i < stmt.column_count(); i++)
167 ATF_REQUIRE(sqlite::type_null == stmt.column_type(i));
168 ATF_REQUIRE(!stmt.step());
169 }
170
171
172 ATF_TEST_CASE_WITHOUT_HEAD(column_type__out_of_range);
ATF_TEST_CASE_BODY(column_type__out_of_range)173 ATF_TEST_CASE_BODY(column_type__out_of_range)
174 {
175 sqlite::database db = sqlite::database::in_memory();
176 db.exec("CREATE TABLE foo (a INTEGER PRIMARY KEY);"
177 "INSERT INTO foo VALUES (1);");
178 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
179 ATF_REQUIRE(stmt.step());
180 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
181 ATF_REQUIRE(sqlite::type_null == stmt.column_type(1));
182 ATF_REQUIRE(sqlite::type_null == stmt.column_type(512));
183 ATF_REQUIRE(!stmt.step());
184 }
185
186
187 ATF_TEST_CASE_WITHOUT_HEAD(column_id__ok);
ATF_TEST_CASE_BODY(column_id__ok)188 ATF_TEST_CASE_BODY(column_id__ok)
189 {
190 sqlite::database db = sqlite::database::in_memory();
191 db.exec("CREATE TABLE foo (bar INTEGER PRIMARY KEY, "
192 " baz INTEGER);"
193 "INSERT INTO foo VALUES (1, 2);");
194 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
195 ATF_REQUIRE(stmt.step());
196 ATF_REQUIRE_EQ(0, stmt.column_id("bar"));
197 ATF_REQUIRE_EQ(1, stmt.column_id("baz"));
198 ATF_REQUIRE_EQ(0, stmt.column_id("bar"));
199 ATF_REQUIRE_EQ(1, stmt.column_id("baz"));
200 ATF_REQUIRE(!stmt.step());
201 }
202
203
204 ATF_TEST_CASE_WITHOUT_HEAD(column_id__missing);
ATF_TEST_CASE_BODY(column_id__missing)205 ATF_TEST_CASE_BODY(column_id__missing)
206 {
207 sqlite::database db = sqlite::database::in_memory();
208 db.exec("CREATE TABLE foo (bar INTEGER PRIMARY KEY, "
209 " baz INTEGER);"
210 "INSERT INTO foo VALUES (1, 2);");
211 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
212 ATF_REQUIRE(stmt.step());
213 ATF_REQUIRE_EQ(0, stmt.column_id("bar"));
214 try {
215 stmt.column_id("bazo");
216 fail("invalid_column_error not raised");
217 } catch (const sqlite::invalid_column_error& e) {
218 ATF_REQUIRE_EQ("bazo", e.column_name());
219 }
220 ATF_REQUIRE(!stmt.step());
221 }
222
223
224 ATF_TEST_CASE_WITHOUT_HEAD(column_blob);
ATF_TEST_CASE_BODY(column_blob)225 ATF_TEST_CASE_BODY(column_blob)
226 {
227 sqlite::database db = sqlite::database::in_memory();
228 db.exec("CREATE TABLE foo (a INTEGER, b BLOB, c INTEGER);"
229 "INSERT INTO foo VALUES (NULL, x'cafe', NULL);");
230 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
231 ATF_REQUIRE(stmt.step());
232 const sqlite::blob blob = stmt.column_blob(1);
233 ATF_REQUIRE_EQ(0xca, static_cast< const uint8_t* >(blob.memory)[0]);
234 ATF_REQUIRE_EQ(0xfe, static_cast< const uint8_t* >(blob.memory)[1]);
235 ATF_REQUIRE(!stmt.step());
236 }
237
238
239 ATF_TEST_CASE_WITHOUT_HEAD(column_double);
ATF_TEST_CASE_BODY(column_double)240 ATF_TEST_CASE_BODY(column_double)
241 {
242 sqlite::database db = sqlite::database::in_memory();
243 db.exec("CREATE TABLE foo (a INTEGER, b DOUBLE, c INTEGER);"
244 "INSERT INTO foo VALUES (NULL, 0.5, NULL);");
245 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
246 ATF_REQUIRE(stmt.step());
247 ATF_REQUIRE_EQ(0.5, stmt.column_double(1));
248 ATF_REQUIRE(!stmt.step());
249 }
250
251
252 ATF_TEST_CASE_WITHOUT_HEAD(column_int__ok);
ATF_TEST_CASE_BODY(column_int__ok)253 ATF_TEST_CASE_BODY(column_int__ok)
254 {
255 sqlite::database db = sqlite::database::in_memory();
256 db.exec("CREATE TABLE foo (a TEXT, b INTEGER, c TEXT);"
257 "INSERT INTO foo VALUES (NULL, 987, NULL);");
258 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
259 ATF_REQUIRE(stmt.step());
260 ATF_REQUIRE_EQ(987, stmt.column_int(1));
261 ATF_REQUIRE(!stmt.step());
262 }
263
264
265 ATF_TEST_CASE_WITHOUT_HEAD(column_int__overflow);
ATF_TEST_CASE_BODY(column_int__overflow)266 ATF_TEST_CASE_BODY(column_int__overflow)
267 {
268 sqlite::database db = sqlite::database::in_memory();
269 db.exec("CREATE TABLE foo (a TEXT, b INTEGER, c TEXT);"
270 "INSERT INTO foo VALUES (NULL, 4294967419, NULL);");
271 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
272 ATF_REQUIRE(stmt.step());
273 ATF_REQUIRE_EQ(123, stmt.column_int(1));
274 ATF_REQUIRE(!stmt.step());
275 }
276
277
278 ATF_TEST_CASE_WITHOUT_HEAD(column_int64);
ATF_TEST_CASE_BODY(column_int64)279 ATF_TEST_CASE_BODY(column_int64)
280 {
281 sqlite::database db = sqlite::database::in_memory();
282 db.exec("CREATE TABLE foo (a TEXT, b INTEGER, c TEXT);"
283 "INSERT INTO foo VALUES (NULL, 4294967419, NULL);");
284 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
285 ATF_REQUIRE(stmt.step());
286 ATF_REQUIRE_EQ(4294967419LL, stmt.column_int64(1));
287 ATF_REQUIRE(!stmt.step());
288 }
289
290
291 ATF_TEST_CASE_WITHOUT_HEAD(column_text);
ATF_TEST_CASE_BODY(column_text)292 ATF_TEST_CASE_BODY(column_text)
293 {
294 sqlite::database db = sqlite::database::in_memory();
295 db.exec("CREATE TABLE foo (a INTEGER, b TEXT, c INTEGER);"
296 "INSERT INTO foo VALUES (NULL, 'foo bar', NULL);");
297 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
298 ATF_REQUIRE(stmt.step());
299 ATF_REQUIRE_EQ("foo bar", stmt.column_text(1));
300 ATF_REQUIRE(!stmt.step());
301 }
302
303
304 ATF_TEST_CASE_WITHOUT_HEAD(column_bytes__blob);
ATF_TEST_CASE_BODY(column_bytes__blob)305 ATF_TEST_CASE_BODY(column_bytes__blob)
306 {
307 sqlite::database db = sqlite::database::in_memory();
308 db.exec("CREATE TABLE foo (a BLOB);"
309 "INSERT INTO foo VALUES (x'12345678');");
310 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
311 ATF_REQUIRE(stmt.step());
312 ATF_REQUIRE_EQ(4, stmt.column_bytes(0));
313 ATF_REQUIRE(!stmt.step());
314 }
315
316
317 ATF_TEST_CASE_WITHOUT_HEAD(column_bytes__text);
ATF_TEST_CASE_BODY(column_bytes__text)318 ATF_TEST_CASE_BODY(column_bytes__text)
319 {
320 sqlite::database db = sqlite::database::in_memory();
321 db.exec("CREATE TABLE foo (a TEXT);"
322 "INSERT INTO foo VALUES ('foo bar');");
323 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
324 ATF_REQUIRE(stmt.step());
325 ATF_REQUIRE_EQ(7, stmt.column_bytes(0));
326 ATF_REQUIRE(!stmt.step());
327 }
328
329
330 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_blob__ok);
ATF_TEST_CASE_BODY(safe_column_blob__ok)331 ATF_TEST_CASE_BODY(safe_column_blob__ok)
332 {
333 sqlite::database db = sqlite::database::in_memory();
334 db.exec("CREATE TABLE foo (a INTEGER, b BLOB, c INTEGER);"
335 "INSERT INTO foo VALUES (NULL, x'cafe', NULL);");
336 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
337 ATF_REQUIRE(stmt.step());
338 const sqlite::blob blob = stmt.safe_column_blob("b");
339 ATF_REQUIRE_EQ(0xca, static_cast< const uint8_t* >(blob.memory)[0]);
340 ATF_REQUIRE_EQ(0xfe, static_cast< const uint8_t* >(blob.memory)[1]);
341 ATF_REQUIRE(!stmt.step());
342 }
343
344
345 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_blob__fail);
ATF_TEST_CASE_BODY(safe_column_blob__fail)346 ATF_TEST_CASE_BODY(safe_column_blob__fail)
347 {
348 sqlite::database db = sqlite::database::in_memory();
349 db.exec("CREATE TABLE foo (a INTEGER);"
350 "INSERT INTO foo VALUES (123);");
351 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
352 ATF_REQUIRE(stmt.step());
353 ATF_REQUIRE_THROW(sqlite::invalid_column_error,
354 stmt.safe_column_blob("b"));
355 ATF_REQUIRE_THROW_RE(sqlite::error, "not a blob",
356 stmt.safe_column_blob("a"));
357 ATF_REQUIRE(!stmt.step());
358 }
359
360
361 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_double__ok);
ATF_TEST_CASE_BODY(safe_column_double__ok)362 ATF_TEST_CASE_BODY(safe_column_double__ok)
363 {
364 sqlite::database db = sqlite::database::in_memory();
365 db.exec("CREATE TABLE foo (a INTEGER, b DOUBLE, c INTEGER);"
366 "INSERT INTO foo VALUES (NULL, 0.5, NULL);");
367 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
368 ATF_REQUIRE(stmt.step());
369 ATF_REQUIRE_EQ(0.5, stmt.safe_column_double("b"));
370 ATF_REQUIRE(!stmt.step());
371 }
372
373
374 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_double__fail);
ATF_TEST_CASE_BODY(safe_column_double__fail)375 ATF_TEST_CASE_BODY(safe_column_double__fail)
376 {
377 sqlite::database db = sqlite::database::in_memory();
378 db.exec("CREATE TABLE foo (a INTEGER);"
379 "INSERT INTO foo VALUES (NULL);");
380 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
381 ATF_REQUIRE(stmt.step());
382 ATF_REQUIRE_THROW(sqlite::invalid_column_error,
383 stmt.safe_column_double("b"));
384 ATF_REQUIRE_THROW_RE(sqlite::error, "not a float",
385 stmt.safe_column_double("a"));
386 ATF_REQUIRE(!stmt.step());
387 }
388
389
390 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_int__ok);
ATF_TEST_CASE_BODY(safe_column_int__ok)391 ATF_TEST_CASE_BODY(safe_column_int__ok)
392 {
393 sqlite::database db = sqlite::database::in_memory();
394 db.exec("CREATE TABLE foo (a TEXT, b INTEGER, c TEXT);"
395 "INSERT INTO foo VALUES (NULL, 987, NULL);");
396 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
397 ATF_REQUIRE(stmt.step());
398 ATF_REQUIRE_EQ(987, stmt.safe_column_int("b"));
399 ATF_REQUIRE(!stmt.step());
400 }
401
402
403 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_int__fail);
ATF_TEST_CASE_BODY(safe_column_int__fail)404 ATF_TEST_CASE_BODY(safe_column_int__fail)
405 {
406 sqlite::database db = sqlite::database::in_memory();
407 db.exec("CREATE TABLE foo (a TEXT);"
408 "INSERT INTO foo VALUES ('def');");
409 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
410 ATF_REQUIRE(stmt.step());
411 ATF_REQUIRE_THROW(sqlite::invalid_column_error,
412 stmt.safe_column_int("b"));
413 ATF_REQUIRE_THROW_RE(sqlite::error, "not an integer",
414 stmt.safe_column_int("a"));
415 ATF_REQUIRE(!stmt.step());
416 }
417
418
419 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_int64__ok);
ATF_TEST_CASE_BODY(safe_column_int64__ok)420 ATF_TEST_CASE_BODY(safe_column_int64__ok)
421 {
422 sqlite::database db = sqlite::database::in_memory();
423 db.exec("CREATE TABLE foo (a TEXT, b INTEGER, c TEXT);"
424 "INSERT INTO foo VALUES (NULL, 4294967419, NULL);");
425 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
426 ATF_REQUIRE(stmt.step());
427 ATF_REQUIRE_EQ(4294967419LL, stmt.safe_column_int64("b"));
428 ATF_REQUIRE(!stmt.step());
429 }
430
431
432 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_int64__fail);
ATF_TEST_CASE_BODY(safe_column_int64__fail)433 ATF_TEST_CASE_BODY(safe_column_int64__fail)
434 {
435 sqlite::database db = sqlite::database::in_memory();
436 db.exec("CREATE TABLE foo (a TEXT);"
437 "INSERT INTO foo VALUES ('abc');");
438 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
439 ATF_REQUIRE(stmt.step());
440 ATF_REQUIRE_THROW(sqlite::invalid_column_error,
441 stmt.safe_column_int64("b"));
442 ATF_REQUIRE_THROW_RE(sqlite::error, "not an integer",
443 stmt.safe_column_int64("a"));
444 ATF_REQUIRE(!stmt.step());
445 }
446
447
448 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_text__ok);
ATF_TEST_CASE_BODY(safe_column_text__ok)449 ATF_TEST_CASE_BODY(safe_column_text__ok)
450 {
451 sqlite::database db = sqlite::database::in_memory();
452 db.exec("CREATE TABLE foo (a INTEGER, b TEXT, c INTEGER);"
453 "INSERT INTO foo VALUES (NULL, 'foo bar', NULL);");
454 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
455 ATF_REQUIRE(stmt.step());
456 ATF_REQUIRE_EQ("foo bar", stmt.safe_column_text("b"));
457 ATF_REQUIRE(!stmt.step());
458 }
459
460
461 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_text__fail);
ATF_TEST_CASE_BODY(safe_column_text__fail)462 ATF_TEST_CASE_BODY(safe_column_text__fail)
463 {
464 sqlite::database db = sqlite::database::in_memory();
465 db.exec("CREATE TABLE foo (a INTEGER);"
466 "INSERT INTO foo VALUES (NULL);");
467 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
468 ATF_REQUIRE(stmt.step());
469 ATF_REQUIRE_THROW(sqlite::invalid_column_error,
470 stmt.safe_column_text("b"));
471 ATF_REQUIRE_THROW_RE(sqlite::error, "not a string",
472 stmt.safe_column_text("a"));
473 ATF_REQUIRE(!stmt.step());
474 }
475
476
477 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_bytes__ok__blob);
ATF_TEST_CASE_BODY(safe_column_bytes__ok__blob)478 ATF_TEST_CASE_BODY(safe_column_bytes__ok__blob)
479 {
480 sqlite::database db = sqlite::database::in_memory();
481 db.exec("CREATE TABLE foo (a BLOB);"
482 "INSERT INTO foo VALUES (x'12345678');");
483 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
484 ATF_REQUIRE(stmt.step());
485 ATF_REQUIRE_EQ(4, stmt.safe_column_bytes("a"));
486 ATF_REQUIRE(!stmt.step());
487 }
488
489
490 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_bytes__ok__text);
ATF_TEST_CASE_BODY(safe_column_bytes__ok__text)491 ATF_TEST_CASE_BODY(safe_column_bytes__ok__text)
492 {
493 sqlite::database db = sqlite::database::in_memory();
494 db.exec("CREATE TABLE foo (a TEXT);"
495 "INSERT INTO foo VALUES ('foo bar');");
496 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
497 ATF_REQUIRE(stmt.step());
498 ATF_REQUIRE_EQ(7, stmt.safe_column_bytes("a"));
499 ATF_REQUIRE(!stmt.step());
500 }
501
502
503 ATF_TEST_CASE_WITHOUT_HEAD(safe_column_bytes__fail);
ATF_TEST_CASE_BODY(safe_column_bytes__fail)504 ATF_TEST_CASE_BODY(safe_column_bytes__fail)
505 {
506 sqlite::database db = sqlite::database::in_memory();
507 db.exec("CREATE TABLE foo (a TEXT);"
508 "INSERT INTO foo VALUES (NULL);");
509 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
510 ATF_REQUIRE(stmt.step());
511 ATF_REQUIRE_THROW(sqlite::invalid_column_error,
512 stmt.safe_column_bytes("b"));
513 ATF_REQUIRE_THROW_RE(sqlite::error, "not a blob or a string",
514 stmt.safe_column_bytes("a"));
515 ATF_REQUIRE(!stmt.step());
516 }
517
518
519 ATF_TEST_CASE_WITHOUT_HEAD(reset);
ATF_TEST_CASE_BODY(reset)520 ATF_TEST_CASE_BODY(reset)
521 {
522 sqlite::database db = sqlite::database::in_memory();
523 db.exec("CREATE TABLE foo (a TEXT);"
524 "INSERT INTO foo VALUES ('foo bar');");
525 sqlite::statement stmt = db.create_statement("SELECT * FROM foo");
526 ATF_REQUIRE(stmt.step());
527 ATF_REQUIRE(!stmt.step());
528 stmt.reset();
529 ATF_REQUIRE(stmt.step());
530 ATF_REQUIRE(!stmt.step());
531 }
532
533
534 ATF_TEST_CASE_WITHOUT_HEAD(bind__blob);
ATF_TEST_CASE_BODY(bind__blob)535 ATF_TEST_CASE_BODY(bind__blob)
536 {
537 sqlite::database db = sqlite::database::in_memory();
538 sqlite::statement stmt = db.create_statement("SELECT 3, ?");
539
540 const unsigned char blob[] = {0xca, 0xfe};
541 stmt.bind(1, sqlite::blob(static_cast< const void* >(blob), 2));
542 ATF_REQUIRE(stmt.step());
543 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
544 ATF_REQUIRE_EQ(3, stmt.column_int(0));
545 ATF_REQUIRE(sqlite::type_blob == stmt.column_type(1));
546 const unsigned char* ret_blob =
547 static_cast< const unsigned char* >(stmt.column_blob(1).memory);
548 ATF_REQUIRE(std::memcmp(blob, ret_blob, 2) == 0);
549 ATF_REQUIRE(!stmt.step());
550 }
551
552
553 ATF_TEST_CASE_WITHOUT_HEAD(bind__double);
ATF_TEST_CASE_BODY(bind__double)554 ATF_TEST_CASE_BODY(bind__double)
555 {
556 sqlite::database db = sqlite::database::in_memory();
557 sqlite::statement stmt = db.create_statement("SELECT 3, ?");
558
559 stmt.bind(1, 0.5);
560 ATF_REQUIRE(stmt.step());
561 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
562 ATF_REQUIRE_EQ(3, stmt.column_int(0));
563 ATF_REQUIRE(sqlite::type_float == stmt.column_type(1));
564 ATF_REQUIRE_EQ(0.5, stmt.column_double(1));
565 ATF_REQUIRE(!stmt.step());
566 }
567
568
569 ATF_TEST_CASE_WITHOUT_HEAD(bind__int);
ATF_TEST_CASE_BODY(bind__int)570 ATF_TEST_CASE_BODY(bind__int)
571 {
572 sqlite::database db = sqlite::database::in_memory();
573 sqlite::statement stmt = db.create_statement("SELECT 3, ?");
574
575 stmt.bind(1, 123);
576 ATF_REQUIRE(stmt.step());
577 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
578 ATF_REQUIRE_EQ(3, stmt.column_int(0));
579 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(1));
580 ATF_REQUIRE_EQ(123, stmt.column_int(1));
581 ATF_REQUIRE(!stmt.step());
582 }
583
584
585 ATF_TEST_CASE_WITHOUT_HEAD(bind__int64);
ATF_TEST_CASE_BODY(bind__int64)586 ATF_TEST_CASE_BODY(bind__int64)
587 {
588 sqlite::database db = sqlite::database::in_memory();
589 sqlite::statement stmt = db.create_statement("SELECT 3, ?");
590
591 stmt.bind(1, static_cast< int64_t >(4294967419LL));
592 ATF_REQUIRE(stmt.step());
593 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
594 ATF_REQUIRE_EQ(3, stmt.column_int(0));
595 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(1));
596 ATF_REQUIRE_EQ(4294967419LL, stmt.column_int64(1));
597 ATF_REQUIRE(!stmt.step());
598 }
599
600
601 ATF_TEST_CASE_WITHOUT_HEAD(bind__null);
ATF_TEST_CASE_BODY(bind__null)602 ATF_TEST_CASE_BODY(bind__null)
603 {
604 sqlite::database db = sqlite::database::in_memory();
605 sqlite::statement stmt = db.create_statement("SELECT 3, ?");
606
607 stmt.bind(1, sqlite::null());
608 ATF_REQUIRE(stmt.step());
609 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
610 ATF_REQUIRE_EQ(3, stmt.column_int(0));
611 ATF_REQUIRE(sqlite::type_null == stmt.column_type(1));
612 ATF_REQUIRE(!stmt.step());
613 }
614
615
616 ATF_TEST_CASE_WITHOUT_HEAD(bind__text);
ATF_TEST_CASE_BODY(bind__text)617 ATF_TEST_CASE_BODY(bind__text)
618 {
619 sqlite::database db = sqlite::database::in_memory();
620 sqlite::statement stmt = db.create_statement("SELECT 3, ?");
621
622 const std::string str = "Hello";
623 stmt.bind(1, str);
624 ATF_REQUIRE(stmt.step());
625 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
626 ATF_REQUIRE_EQ(3, stmt.column_int(0));
627 ATF_REQUIRE(sqlite::type_text == stmt.column_type(1));
628 ATF_REQUIRE_EQ(str, stmt.column_text(1));
629 ATF_REQUIRE(!stmt.step());
630 }
631
632
633 ATF_TEST_CASE_WITHOUT_HEAD(bind__text__transient);
ATF_TEST_CASE_BODY(bind__text__transient)634 ATF_TEST_CASE_BODY(bind__text__transient)
635 {
636 sqlite::database db = sqlite::database::in_memory();
637 sqlite::statement stmt = db.create_statement("SELECT 3, :foo");
638
639 {
640 const std::string str = "Hello";
641 stmt.bind(":foo", str);
642 }
643
644 ATF_REQUIRE(stmt.step());
645 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
646 ATF_REQUIRE_EQ(3, stmt.column_int(0));
647 ATF_REQUIRE(sqlite::type_text == stmt.column_type(1));
648 ATF_REQUIRE_EQ(std::string("Hello"), stmt.column_text(1));
649 ATF_REQUIRE(!stmt.step());
650 }
651
652
653 ATF_TEST_CASE_WITHOUT_HEAD(bind__by_name);
ATF_TEST_CASE_BODY(bind__by_name)654 ATF_TEST_CASE_BODY(bind__by_name)
655 {
656 sqlite::database db = sqlite::database::in_memory();
657 sqlite::statement stmt = db.create_statement("SELECT 3, :foo");
658
659 const std::string str = "Hello";
660 stmt.bind(":foo", str);
661 ATF_REQUIRE(stmt.step());
662 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
663 ATF_REQUIRE_EQ(3, stmt.column_int(0));
664 ATF_REQUIRE(sqlite::type_text == stmt.column_type(1));
665 ATF_REQUIRE_EQ(str, stmt.column_text(1));
666 ATF_REQUIRE(!stmt.step());
667 }
668
669
670 ATF_TEST_CASE_WITHOUT_HEAD(bind_parameter_count);
ATF_TEST_CASE_BODY(bind_parameter_count)671 ATF_TEST_CASE_BODY(bind_parameter_count)
672 {
673 sqlite::database db = sqlite::database::in_memory();
674 sqlite::statement stmt = db.create_statement("SELECT 3, ?, ?");
675 ATF_REQUIRE_EQ(2, stmt.bind_parameter_count());
676 }
677
678
679 ATF_TEST_CASE_WITHOUT_HEAD(bind_parameter_index);
ATF_TEST_CASE_BODY(bind_parameter_index)680 ATF_TEST_CASE_BODY(bind_parameter_index)
681 {
682 sqlite::database db = sqlite::database::in_memory();
683 sqlite::statement stmt = db.create_statement("SELECT 3, :foo, ?, :bar");
684 ATF_REQUIRE_EQ(1, stmt.bind_parameter_index(":foo"));
685 ATF_REQUIRE_EQ(3, stmt.bind_parameter_index(":bar"));
686 }
687
688
689 ATF_TEST_CASE_WITHOUT_HEAD(bind_parameter_name);
ATF_TEST_CASE_BODY(bind_parameter_name)690 ATF_TEST_CASE_BODY(bind_parameter_name)
691 {
692 sqlite::database db = sqlite::database::in_memory();
693 sqlite::statement stmt = db.create_statement("SELECT 3, :foo, ?, :bar");
694 ATF_REQUIRE_EQ(":foo", stmt.bind_parameter_name(1));
695 ATF_REQUIRE_EQ(":bar", stmt.bind_parameter_name(3));
696 }
697
698
699 ATF_TEST_CASE_WITHOUT_HEAD(clear_bindings);
ATF_TEST_CASE_BODY(clear_bindings)700 ATF_TEST_CASE_BODY(clear_bindings)
701 {
702 sqlite::database db = sqlite::database::in_memory();
703 sqlite::statement stmt = db.create_statement("SELECT 3, ?");
704
705 stmt.bind(1, 5);
706 ATF_REQUIRE(stmt.step());
707 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
708 ATF_REQUIRE_EQ(3, stmt.column_int(0));
709 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(1));
710 ATF_REQUIRE_EQ(5, stmt.column_int(1));
711 stmt.clear_bindings();
712 stmt.reset();
713
714 ATF_REQUIRE(stmt.step());
715 ATF_REQUIRE(sqlite::type_integer == stmt.column_type(0));
716 ATF_REQUIRE_EQ(3, stmt.column_int(0));
717 ATF_REQUIRE(sqlite::type_null == stmt.column_type(1));
718
719 ATF_REQUIRE(!stmt.step());
720 }
721
722
ATF_INIT_TEST_CASES(tcs)723 ATF_INIT_TEST_CASES(tcs)
724 {
725 ATF_ADD_TEST_CASE(tcs, step__ok);
726 ATF_ADD_TEST_CASE(tcs, step__many);
727 ATF_ADD_TEST_CASE(tcs, step__fail);
728
729 ATF_ADD_TEST_CASE(tcs, step_without_results__ok);
730 ATF_ADD_TEST_CASE(tcs, step_without_results__fail);
731
732 ATF_ADD_TEST_CASE(tcs, column_count);
733
734 ATF_ADD_TEST_CASE(tcs, column_name__ok);
735 ATF_ADD_TEST_CASE(tcs, column_name__fail);
736
737 ATF_ADD_TEST_CASE(tcs, column_type__ok);
738 ATF_ADD_TEST_CASE(tcs, column_type__out_of_range);
739
740 ATF_ADD_TEST_CASE(tcs, column_id__ok);
741 ATF_ADD_TEST_CASE(tcs, column_id__missing);
742
743 ATF_ADD_TEST_CASE(tcs, column_blob);
744 ATF_ADD_TEST_CASE(tcs, column_double);
745 ATF_ADD_TEST_CASE(tcs, column_int__ok);
746 ATF_ADD_TEST_CASE(tcs, column_int__overflow);
747 ATF_ADD_TEST_CASE(tcs, column_int64);
748 ATF_ADD_TEST_CASE(tcs, column_text);
749
750 ATF_ADD_TEST_CASE(tcs, column_bytes__blob);
751 ATF_ADD_TEST_CASE(tcs, column_bytes__text);
752
753 ATF_ADD_TEST_CASE(tcs, safe_column_blob__ok);
754 ATF_ADD_TEST_CASE(tcs, safe_column_blob__fail);
755 ATF_ADD_TEST_CASE(tcs, safe_column_double__ok);
756 ATF_ADD_TEST_CASE(tcs, safe_column_double__fail);
757 ATF_ADD_TEST_CASE(tcs, safe_column_int__ok);
758 ATF_ADD_TEST_CASE(tcs, safe_column_int__fail);
759 ATF_ADD_TEST_CASE(tcs, safe_column_int64__ok);
760 ATF_ADD_TEST_CASE(tcs, safe_column_int64__fail);
761 ATF_ADD_TEST_CASE(tcs, safe_column_text__ok);
762 ATF_ADD_TEST_CASE(tcs, safe_column_text__fail);
763
764 ATF_ADD_TEST_CASE(tcs, safe_column_bytes__ok__blob);
765 ATF_ADD_TEST_CASE(tcs, safe_column_bytes__ok__text);
766 ATF_ADD_TEST_CASE(tcs, safe_column_bytes__fail);
767
768 ATF_ADD_TEST_CASE(tcs, reset);
769
770 ATF_ADD_TEST_CASE(tcs, bind__blob);
771 ATF_ADD_TEST_CASE(tcs, bind__double);
772 ATF_ADD_TEST_CASE(tcs, bind__int64);
773 ATF_ADD_TEST_CASE(tcs, bind__int);
774 ATF_ADD_TEST_CASE(tcs, bind__null);
775 ATF_ADD_TEST_CASE(tcs, bind__text);
776 ATF_ADD_TEST_CASE(tcs, bind__text__transient);
777 ATF_ADD_TEST_CASE(tcs, bind__by_name);
778
779 ATF_ADD_TEST_CASE(tcs, bind_parameter_count);
780 ATF_ADD_TEST_CASE(tcs, bind_parameter_index);
781 ATF_ADD_TEST_CASE(tcs, bind_parameter_name);
782
783 ATF_ADD_TEST_CASE(tcs, clear_bindings);
784 }
785