Home | History | Annotate | Line # | Download | only in sqlite 
      1 // Copyright 2011 Google Inc.
      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);
     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);
     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);
     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);
     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);
     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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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);
    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 
    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