utils/sqlite/statement_test.cpp

   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);
  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 }