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 } 785