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 "cli/cmd_db_exec.hpp" 30 31#include <cstring> 32 33#include <atf-c++.hpp> 34 35#include "utils/format/macros.hpp" 36#include "utils/sqlite/database.hpp" 37#include "utils/sqlite/statement.ipp" 38 39namespace sqlite = utils::sqlite; 40 41 42namespace { 43 44 45/// Performs a test for the cli::format_cell() function. 46/// 47/// \tparam Cell The type of the value to insert into the test column. 48/// \param column_type The SQL type of the test column. 49/// \param value The value to insert into the test column. 50/// \param exp_value The expected return value of cli::format_cell(). 51template< class Cell > 52static void 53do_format_cell_test(const std::string column_type, 54 const Cell& value, const std::string& exp_value) 55{ 56 sqlite::database db = sqlite::database::in_memory(); 57 58 sqlite::statement create = db.create_statement( 59 F("CREATE TABLE test (column %s)") % column_type); 60 create.step_without_results(); 61 62 sqlite::statement insert = db.create_statement( 63 "INSERT INTO test (column) VALUES (:column)"); 64 insert.bind(":column", value); 65 insert.step_without_results(); 66 67 sqlite::statement query = db.create_statement("SELECT * FROM test"); 68 ATF_REQUIRE(query.step()); 69 ATF_REQUIRE_EQ(exp_value, cli::format_cell(query, 0)); 70 ATF_REQUIRE(!query.step()); 71} 72 73 74} // anonymous namespace 75 76 77ATF_TEST_CASE_WITHOUT_HEAD(format_cell__blob); 78ATF_TEST_CASE_BODY(format_cell__blob) 79{ 80 const char* contents = "Some random contents"; 81 do_format_cell_test( 82 "BLOB", sqlite::blob(contents, std::strlen(contents)), 83 F("BLOB of %s bytes") % strlen(contents)); 84} 85 86 87ATF_TEST_CASE_WITHOUT_HEAD(format_cell__float); 88ATF_TEST_CASE_BODY(format_cell__float) 89{ 90 do_format_cell_test("FLOAT", 3.5, "3.5"); 91} 92 93 94ATF_TEST_CASE_WITHOUT_HEAD(format_cell__integer); 95ATF_TEST_CASE_BODY(format_cell__integer) 96{ 97 do_format_cell_test("INTEGER", 123456, "123456"); 98} 99 100 101ATF_TEST_CASE_WITHOUT_HEAD(format_cell__null); 102ATF_TEST_CASE_BODY(format_cell__null) 103{ 104 do_format_cell_test("TEXT", sqlite::null(), "NULL"); 105} 106 107 108ATF_TEST_CASE_WITHOUT_HEAD(format_cell__text); 109ATF_TEST_CASE_BODY(format_cell__text) 110{ 111 do_format_cell_test("TEXT", "Hello, world", "Hello, world"); 112} 113 114 115ATF_TEST_CASE_WITHOUT_HEAD(format_headers); 116ATF_TEST_CASE_BODY(format_headers) 117{ 118 sqlite::database db = sqlite::database::in_memory(); 119 120 sqlite::statement create = db.create_statement( 121 "CREATE TABLE test (c1 TEXT, c2 TEXT, c3 TEXT)"); 122 create.step_without_results(); 123 124 sqlite::statement query = db.create_statement( 125 "SELECT c1, c2, c3 AS c3bis FROM test"); 126 ATF_REQUIRE_EQ("c1,c2,c3bis", cli::format_headers(query)); 127} 128 129 130ATF_TEST_CASE_WITHOUT_HEAD(format_row); 131ATF_TEST_CASE_BODY(format_row) 132{ 133 sqlite::database db = sqlite::database::in_memory(); 134 135 sqlite::statement create = db.create_statement( 136 "CREATE TABLE test (c1 TEXT, c2 BLOB)"); 137 create.step_without_results(); 138 139 const char* memory = "BLOB contents"; 140 sqlite::statement insert = db.create_statement( 141 "INSERT INTO test VALUES (:v1, :v2)"); 142 insert.bind(":v1", "A string"); 143 insert.bind(":v2", sqlite::blob(memory, std::strlen(memory))); 144 insert.step_without_results(); 145 146 sqlite::statement query = db.create_statement("SELECT * FROM test"); 147 query.step(); 148 ATF_REQUIRE_EQ( 149 (F("A string,BLOB of %s bytes") % std::strlen(memory)).str(), 150 cli::format_row(query)); 151} 152 153 154ATF_INIT_TEST_CASES(tcs) 155{ 156 ATF_ADD_TEST_CASE(tcs, format_cell__blob); 157 ATF_ADD_TEST_CASE(tcs, format_cell__float); 158 ATF_ADD_TEST_CASE(tcs, format_cell__integer); 159 ATF_ADD_TEST_CASE(tcs, format_cell__null); 160 ATF_ADD_TEST_CASE(tcs, format_cell__text); 161 162 ATF_ADD_TEST_CASE(tcs, format_headers); 163 164 ATF_ADD_TEST_CASE(tcs, format_row); 165} 166