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
31extern "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
43namespace sqlite = utils::sqlite;
44
45
46ATF_TEST_CASE_WITHOUT_HEAD(step__ok);
47ATF_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
58ATF_TEST_CASE_WITHOUT_HEAD(step__many);
59ATF_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
71ATF_TEST_CASE_WITHOUT_HEAD(step__fail);
72ATF_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
82ATF_TEST_CASE_WITHOUT_HEAD(step_without_results__ok);
83ATF_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
94ATF_TEST_CASE_WITHOUT_HEAD(step_without_results__fail);
95ATF_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
106ATF_TEST_CASE_WITHOUT_HEAD(column_count);
107ATF_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
119ATF_TEST_CASE_WITHOUT_HEAD(column_name__ok);
120ATF_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
133ATF_TEST_CASE_WITHOUT_HEAD(column_name__fail);
134ATF_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
147ATF_TEST_CASE_WITHOUT_HEAD(column_type__ok);
148ATF_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
172ATF_TEST_CASE_WITHOUT_HEAD(column_type__out_of_range);
173ATF_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
187ATF_TEST_CASE_WITHOUT_HEAD(column_id__ok);
188ATF_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
204ATF_TEST_CASE_WITHOUT_HEAD(column_id__missing);
205ATF_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
224ATF_TEST_CASE_WITHOUT_HEAD(column_blob);
225ATF_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
239ATF_TEST_CASE_WITHOUT_HEAD(column_double);
240ATF_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
252ATF_TEST_CASE_WITHOUT_HEAD(column_int__ok);
253ATF_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
265ATF_TEST_CASE_WITHOUT_HEAD(column_int__overflow);
266ATF_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
278ATF_TEST_CASE_WITHOUT_HEAD(column_int64);
279ATF_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
291ATF_TEST_CASE_WITHOUT_HEAD(column_text);
292ATF_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
304ATF_TEST_CASE_WITHOUT_HEAD(column_bytes__blob);
305ATF_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
317ATF_TEST_CASE_WITHOUT_HEAD(column_bytes__text);
318ATF_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
330ATF_TEST_CASE_WITHOUT_HEAD(safe_column_blob__ok);
331ATF_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
345ATF_TEST_CASE_WITHOUT_HEAD(safe_column_blob__fail);
346ATF_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
361ATF_TEST_CASE_WITHOUT_HEAD(safe_column_double__ok);
362ATF_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
374ATF_TEST_CASE_WITHOUT_HEAD(safe_column_double__fail);
375ATF_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
390ATF_TEST_CASE_WITHOUT_HEAD(safe_column_int__ok);
391ATF_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
403ATF_TEST_CASE_WITHOUT_HEAD(safe_column_int__fail);
404ATF_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
419ATF_TEST_CASE_WITHOUT_HEAD(safe_column_int64__ok);
420ATF_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
432ATF_TEST_CASE_WITHOUT_HEAD(safe_column_int64__fail);
433ATF_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
448ATF_TEST_CASE_WITHOUT_HEAD(safe_column_text__ok);
449ATF_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
461ATF_TEST_CASE_WITHOUT_HEAD(safe_column_text__fail);
462ATF_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
477ATF_TEST_CASE_WITHOUT_HEAD(safe_column_bytes__ok__blob);
478ATF_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
490ATF_TEST_CASE_WITHOUT_HEAD(safe_column_bytes__ok__text);
491ATF_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
503ATF_TEST_CASE_WITHOUT_HEAD(safe_column_bytes__fail);
504ATF_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
519ATF_TEST_CASE_WITHOUT_HEAD(reset);
520ATF_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
534ATF_TEST_CASE_WITHOUT_HEAD(bind__blob);
535ATF_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
553ATF_TEST_CASE_WITHOUT_HEAD(bind__double);
554ATF_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
569ATF_TEST_CASE_WITHOUT_HEAD(bind__int);
570ATF_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
585ATF_TEST_CASE_WITHOUT_HEAD(bind__int64);
586ATF_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
601ATF_TEST_CASE_WITHOUT_HEAD(bind__null);
602ATF_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
616ATF_TEST_CASE_WITHOUT_HEAD(bind__text);
617ATF_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
633ATF_TEST_CASE_WITHOUT_HEAD(bind__text__transient);
634ATF_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
653ATF_TEST_CASE_WITHOUT_HEAD(bind__by_name);
654ATF_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
670ATF_TEST_CASE_WITHOUT_HEAD(bind_parameter_count);
671ATF_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
679ATF_TEST_CASE_WITHOUT_HEAD(bind_parameter_index);
680ATF_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
689ATF_TEST_CASE_WITHOUT_HEAD(bind_parameter_name);
690ATF_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
699ATF_TEST_CASE_WITHOUT_HEAD(clear_bindings);
700ATF_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
723ATF_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