RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 05:57:44 +00:00
Code Issues Activity Actions

Tests: Prefer TRY_OR_FAIL() and MUST() over EXPECT(!.is_error())

Browse source 
Note that in some cases (in particular SQL::Result and PDFErrorOr),
there is no Formatter defined for the error type, hence TRY_OR_FAIL
cannot work as-is. Furthermore, this commit leaves untouched the places
where MUST could be replaced by TRY_OR_FAIL.

Inspired by:
https://github.com/SerenityOS/serenity/pull/18710#discussion_r1186892445
This commit is contained in:
Ben Wiederhake 2023-05-07 20:14:06 +02:00 • committed by Andrew Kaster
parent 87a7299078
commit f890b70eae
23 changed files with 415 additions and 742 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Tests/LibSQL/TestSqlBtreeIndex.cpp
View file

@ -146,7 +146,7 @@ void insert_and_get_to_and_from_btree(int num_keys)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto btree = setup_btree(serializer);
@ -163,7 +163,7 @@ void insert_and_get_to_and_from_btree(int num_keys)
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto btree = setup_btree(serializer);
@ -182,7 +182,7 @@ void insert_into_and_scan_btree(int num_keys)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto btree = setup_btree(serializer);
@ -200,7 +200,7 @@ void insert_into_and_scan_btree(int num_keys)
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto btree = setup_btree(serializer);

43
Tests/LibSQL/TestSqlDatabase.cpp
View file

@ -25,8 +25,7 @@ void commit(SQL::Database&);
NonnullRefPtr<SQL::SchemaDef> setup_schema(SQL::Database& db)
{
auto schema = SQL::SchemaDef::construct("TestSchema");
auto maybe_error = db.add_schema(schema);
EXPECT(!maybe_error.is_error());
MUST(db.add_schema(schema));
return schema;
}
@ -37,8 +36,7 @@ NonnullRefPtr<SQL::TableDef> setup_table(SQL::Database& db)
table->append_column("TextColumn", SQL::SQLType::Text);
table->append_column("IntColumn", SQL::SQLType::Integer);
EXPECT_EQ(table->num_columns(), 2u);
auto maybe_error = db.add_table(table);
EXPECT(!maybe_error.is_error());
MUST(db.add_table(table));
return table;
}
@ -53,8 +51,7 @@ void insert_into_table(SQL::Database& db, int count)
row["TextColumn"] = builder.to_deprecated_string();
row["IntColumn"] = ix;
auto maybe_error = db.insert(row);
EXPECT(!maybe_error.is_error());
TRY_OR_FAIL(db.insert(row));
}
}
@ -64,9 +61,8 @@ void verify_table_contents(SQL::Database& db, int expected_count)
int sum = 0;
int count = 0;
auto rows_or_error = db.select_all(*table);
EXPECT(!rows_or_error.is_error());
for (auto& row : rows_or_error.value()) {
auto rows = TRY_OR_FAIL(db.select_all(*table));
for (auto& row : rows) {
StringBuilder builder;
builder.appendff("Test{}", row["IntColumn"].to_int<i32>().value());
EXPECT_EQ(row["TextColumn"].to_deprecated_string(), builder.to_deprecated_string());
@ -79,8 +75,7 @@ void verify_table_contents(SQL::Database& db, int expected_count)
void commit(SQL::Database& db)
{
auto maybe_error = db.commit();
EXPECT(!maybe_error.is_error());
TRY_OR_FAIL(db.commit());
}
void insert_and_verify(int count)
@ -88,19 +83,19 @@ void insert_and_verify(int count)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
(void)setup_table(db);
commit(db);
}
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
insert_into_table(db, count);
commit(db);
}
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
verify_table_contents(db, count);
}
}
@ -109,7 +104,7 @@ TEST_CASE(create_heap)
{
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
EXPECT_EQ(heap->version(), SQL::Heap::VERSION);
}
@ -138,8 +133,7 @@ TEST_CASE(create_database)
{
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
auto db = SQL::Database::construct("/tmp/test.db");
auto should_not_be_error = db->open();
EXPECT(!should_not_be_error.is_error());
MUST(db->open());
commit(db);
}
@ -147,7 +141,7 @@ TEST_CASE(add_schema_to_database)
{
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
(void)setup_schema(db);
commit(db);
}
@ -157,15 +151,14 @@ TEST_CASE(get_schema_from_database)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
(void)setup_schema(db);
commit(db);
}
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
auto schema_or_error = db->get_schema("TestSchema");
EXPECT(!schema_or_error.is_error());
MUST(db->open());
auto schema = MUST(db->get_schema("TestSchema"));
}
}
@ -173,7 +166,7 @@ TEST_CASE(add_table_to_database)
{
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
(void)setup_table(db);
commit(db);
}
@ -183,13 +176,13 @@ TEST_CASE(get_table_from_database)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
(void)setup_table(db);
commit(db);
}
{
auto db = SQL::Database::construct("/tmp/test.db");
EXPECT(!db->open().is_error());
MUST(db->open());
auto table = MUST(db->get_table("TestSchema", "TestTable"));
EXPECT_EQ(table->name(), "TestTable");

107
Tests/LibSQL/TestSqlExpressionParser.cpp
View file

@ -58,10 +58,7 @@ TEST_CASE(numeric_literal)
// EXPECT(parse("0x"sv).is_error());
auto validate = [](StringView sql, double expected_value) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::NumericLiteral>(*expression));
const auto& literal = static_cast<const SQL::AST::NumericLiteral&>(*expression);
@ -82,10 +79,7 @@ TEST_CASE(string_literal)
EXPECT(parse("'unterminated"sv).is_error());
auto validate = [](StringView sql, StringView expected_value) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::StringLiteral>(*expression));
const auto& literal = static_cast<const SQL::AST::StringLiteral&>(*expression);
@ -104,10 +98,7 @@ TEST_CASE(blob_literal)
EXPECT(parse("x'NOTHEX'"sv).is_error());
auto validate = [](StringView sql, StringView expected_value) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::BlobLiteral>(*expression));
const auto& literal = static_cast<const SQL::AST::BlobLiteral&>(*expression);
@ -121,10 +112,7 @@ TEST_CASE(blob_literal)
TEST_CASE(boolean_literal)
{
auto validate = [](StringView sql, bool expected_value) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::BooleanLiteral>(*expression));
auto const& literal = static_cast<SQL::AST::BooleanLiteral const&>(*expression);
@ -138,10 +126,7 @@ TEST_CASE(boolean_literal)
TEST_CASE(null_literal)
{
auto validate = [](StringView sql) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::NullLiteral>(*expression));
};
@ -151,10 +136,7 @@ TEST_CASE(null_literal)
TEST_CASE(bind_parameter)
{
auto validate = [](StringView sql) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Placeholder>(*expression));
};
@ -169,10 +151,7 @@ TEST_CASE(column_name)
EXPECT(parse("\"unterminated"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::ColumnNameExpression>(*expression));
const auto& column = static_cast<const SQL::AST::ColumnNameExpression&>(*expression);
@ -199,10 +178,7 @@ TEST_CASE(unary_operator)
EXPECT(parse("NOT"sv).is_error());
auto validate = [](StringView sql, SQL::AST::UnaryOperator expected_operator) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::UnaryOperatorExpression>(*expression));
const auto& unary = static_cast<const SQL::AST::UnaryOperatorExpression&>(*expression);
@ -261,10 +237,7 @@ TEST_CASE(binary_operator)
}
auto validate = [](StringView sql, SQL::AST::BinaryOperator expected_operator) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::BinaryOperatorExpression>(*expression));
const auto& binary = static_cast<const SQL::AST::BinaryOperatorExpression&>(*expression);
@ -289,10 +262,7 @@ TEST_CASE(chained_expression)
EXPECT(parse("(15,)"sv).is_error());
auto validate = [](StringView sql, size_t expected_chain_size) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::ChainedExpression>(*expression));
const auto& chain = static_cast<const SQL::AST::ChainedExpression&>(*expression).expressions();
@ -318,12 +288,7 @@ TEST_CASE(cast_expression)
EXPECT(parse("CAST (15 AS int"sv).is_error());
auto validate = [](StringView sql, StringView expected_type_name) {
auto result = parse(sql);
if (result.is_error())
outln("{}: {}", sql, result.error());
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::CastExpression>(*expression));
const auto& cast = static_cast<const SQL::AST::CastExpression&>(*expression);
@ -354,10 +319,7 @@ TEST_CASE(case_expression)
EXPECT(parse("CASE WHEN 15 THEN 16 ELSE END"sv).is_error());
auto validate = [](StringView sql, bool expect_case_expression, size_t expected_when_then_size, bool expect_else_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::CaseExpression>(*expression));
const auto& case_ = static_cast<const SQL::AST::CaseExpression&>(*expression);
@ -407,10 +369,7 @@ TEST_CASE(exists_expression)
EXPECT(parse("(SELECT * FROM table_name"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::ExistsExpression>(*expression));
const auto& exists = static_cast<const SQL::AST::ExistsExpression&>(*expression);
@ -429,10 +388,7 @@ TEST_CASE(collate_expression)
EXPECT(parse("15 COLLATE"sv).is_error());
auto validate = [](StringView sql, StringView expected_collation_name) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::CollateExpression>(*expression));
const auto& collate = static_cast<const SQL::AST::CollateExpression&>(*expression);
@ -454,10 +410,7 @@ TEST_CASE(is_expression)
EXPECT(parse("1 IS NOT"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::IsExpression>(*expression));
const auto& is_ = static_cast<const SQL::AST::IsExpression&>(*expression);
@ -494,10 +447,7 @@ TEST_CASE(match_expression)
}
auto validate = [](StringView sql, SQL::AST::MatchOperator expected_operator, bool expected_invert_expression, bool expect_escape) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::MatchExpression>(*expression));
const auto& match = static_cast<const SQL::AST::MatchExpression&>(*expression);
@ -536,10 +486,7 @@ TEST_CASE(null_expression)
EXPECT(parse("15 NOT"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::NullExpression>(*expression));
const auto& null = static_cast<const SQL::AST::NullExpression&>(*expression);
@ -563,10 +510,7 @@ TEST_CASE(between_expression)
EXPECT(parse("15 BETWEEN 10 OR 20"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::BetweenExpression>(*expression));
const auto& between = static_cast<const SQL::AST::BetweenExpression&>(*expression);
@ -588,10 +532,7 @@ TEST_CASE(in_table_expression)
EXPECT(parse("NOT IN table_name"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::InTableExpression>(*expression));
const auto& in = static_cast<const SQL::AST::InTableExpression&>(*expression);
@ -614,10 +555,7 @@ TEST_CASE(in_chained_expression)
EXPECT(parse("NOT IN ()"sv).is_error());
auto validate = [](StringView sql, size_t expected_chain_size, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::InChainedExpression>(*expression));
const auto& in = static_cast<const SQL::AST::InChainedExpression&>(*expression);
@ -646,10 +584,7 @@ TEST_CASE(in_selection_expression)
EXPECT(parse("NOT IN (SELECT * FROM table_name, SELECT * FROM table_name);"sv).is_error());
auto validate = [](StringView sql, bool expected_invert_expression) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto expression = result.release_value();
auto expression = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::InSelectionExpression>(*expression));
const auto& in = static_cast<const SQL::AST::InSelectionExpression&>(*expression);

8
Tests/LibSQL/TestSqlHashIndex.cpp
View file

@ -141,7 +141,7 @@ void insert_and_get_to_and_from_hash_index(int num_keys)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto hash_index = setup_hash_index(serializer);
@ -159,7 +159,7 @@ void insert_and_get_to_and_from_hash_index(int num_keys)
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto hash_index = setup_hash_index(serializer);
@ -239,7 +239,7 @@ void insert_into_and_scan_hash_index(int num_keys)
ScopeGuard guard([]() { unlink("/tmp/test.db"); });
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto hash_index = setup_hash_index(serializer);
@ -257,7 +257,7 @@ void insert_into_and_scan_hash_index(int num_keys)
{
auto heap = SQL::Heap::construct("/tmp/test.db");
EXPECT(!heap->open().is_error());
TRY_OR_FAIL(heap->open());
SQL::Serializer serializer(heap);
auto hash_index = setup_hash_index(serializer);
Vector<bool> found;

114
Tests/LibSQL/TestSqlStatementExecution.cpp
View file

@ -73,27 +73,25 @@ TEST_CASE(create_schema)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_schema(database);
auto schema_or_error = database->get_schema("TESTSCHEMA");
EXPECT(!schema_or_error.is_error());
auto schema = MUST(database->get_schema("TESTSCHEMA"));
}
TEST_CASE(create_table)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto table_or_error = database->get_table("TESTSCHEMA", "TESTTABLE");
EXPECT(!table_or_error.is_error());
auto table = MUST(database->get_table("TESTSCHEMA", "TESTTABLE"));
}
TEST_CASE(insert_into_table)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ( 'Test', 42 );");
EXPECT(result.size() == 1);
@ -101,9 +99,8 @@ TEST_CASE(insert_into_table)
auto table = MUST(database->get_table("TESTSCHEMA", "TESTTABLE"));
int count = 0;
auto rows_or_error = database->select_all(*table);
EXPECT(!rows_or_error.is_error());
for (auto& row : rows_or_error.value()) {
auto rows = TRY_OR_FAIL(database->select_all(*table));
for (auto& row : rows) {
EXPECT_EQ(row["TEXTCOLUMN"].to_deprecated_string(), "Test");
EXPECT_EQ(row["INTCOLUMN"].to_int<i32>(), 42);
count++;
@ -115,7 +112,7 @@ TEST_CASE(insert_into_table_wrong_data_types)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = try_execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES (43, 'Test_2');");
EXPECT(result.is_error());
@ -126,7 +123,7 @@ TEST_CASE(insert_into_table_multiple_tuples_wrong_data_types)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = try_execute(database, "INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES ('Test_1', 42), (43, 'Test_2');");
EXPECT(result.is_error());
@ -137,7 +134,7 @@ TEST_CASE(insert_wrong_number_of_values)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = try_execute(database, "INSERT INTO TestSchema.TestTable VALUES ( 42 );");
EXPECT(result.is_error());
@ -148,7 +145,7 @@ TEST_CASE(insert_identifier_as_value)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = try_execute(database, "INSERT INTO TestSchema.TestTable VALUES ( identifier, 42 );");
EXPECT(result.is_error());
@ -159,7 +156,7 @@ TEST_CASE(insert_quoted_identifier_as_value)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = try_execute(database, "INSERT INTO TestSchema.TestTable VALUES ( \"QuotedIdentifier\", 42 );");
EXPECT(result.is_error());
@ -170,15 +167,14 @@ TEST_CASE(insert_without_column_names)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database, "INSERT INTO TestSchema.TestTable VALUES ('Test_1', 42), ('Test_2', 43);");
EXPECT(result.size() == 2);
auto table = MUST(database->get_table("TESTSCHEMA", "TESTTABLE"));
auto rows_or_error = database->select_all(*table);
EXPECT(!rows_or_error.is_error());
EXPECT_EQ(rows_or_error.value().size(), 2u);
auto rows = TRY_OR_FAIL(database->select_all(*table));
EXPECT_EQ(rows.size(), 2u);
}
TEST_CASE(insert_with_placeholders)
@ -186,7 +182,7 @@ TEST_CASE(insert_with_placeholders)
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
{
@ -238,7 +234,7 @@ TEST_CASE(insert_and_retrieve_long_text_value)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
StringBuilder sb;
@ -256,7 +252,7 @@ TEST_CASE(select_from_empty_table)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database, "SELECT * FROM TestSchema.TestTable;");
EXPECT(result.is_empty());
@ -266,7 +262,7 @@ TEST_CASE(select_from_table)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -284,7 +280,7 @@ TEST_CASE(select_with_column_names)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -303,7 +299,7 @@ TEST_CASE(select_with_nonexisting_column_name)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -323,7 +319,7 @@ TEST_CASE(select_with_where)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -344,7 +340,7 @@ TEST_CASE(select_cross_join)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_two_tables(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable1 ( TextColumn1, IntColumn ) VALUES "
@ -377,7 +373,7 @@ TEST_CASE(select_inner_join)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_two_tables(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable1 ( TextColumn1, IntColumn ) VALUES "
@ -410,7 +406,7 @@ TEST_CASE(select_with_like)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -468,7 +464,7 @@ TEST_CASE(select_with_order)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -500,7 +496,7 @@ TEST_CASE(select_with_regexp)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -535,7 +531,7 @@ TEST_CASE(handle_regexp_errors)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -551,7 +547,7 @@ TEST_CASE(select_with_order_two_columns)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -580,7 +576,7 @@ TEST_CASE(select_with_order_by_column_not_in_result)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database,
"INSERT INTO TestSchema.TestTable ( TextColumn, IntColumn ) VALUES "
@ -604,7 +600,7 @@ TEST_CASE(select_with_limit)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 100; count++) {
auto result = execute(database,
@ -620,7 +616,7 @@ TEST_CASE(select_with_limit_and_offset)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 100; count++) {
auto result = execute(database,
@ -635,7 +631,7 @@ TEST_CASE(select_with_order_limit_and_offset)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 100; count++) {
auto result = execute(database,
@ -660,7 +656,7 @@ TEST_CASE(select_with_limit_out_of_bounds)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 100; count++) {
auto result = execute(database,
@ -675,7 +671,7 @@ TEST_CASE(select_with_offset_out_of_bounds)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 100; count++) {
auto result = execute(database,
@ -690,7 +686,7 @@ TEST_CASE(describe_table)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
auto result = execute(database, "DESCRIBE TABLE TestSchema.TestTable;");
EXPECT_EQ(result.size(), 2u);
@ -706,7 +702,7 @@ TEST_CASE(binary_operator_execution)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -780,7 +776,7 @@ TEST_CASE(binary_operator_failure)
{
ScopeGuard guard([]() { unlink(db_name); });
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -831,14 +827,14 @@ TEST_CASE(describe_large_table_after_persist)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "CREATE TABLE Cookies ( name TEXT, value TEXT, same_site INTEGER, creation_time INTEGER, last_access_time INTEGER, expiry_time INTEGER, domain TEXT, path TEXT, secure INTEGER, http_only INTEGER, host_only INTEGER, persistent INTEGER );");
EXPECT_EQ(result.command(), SQL::SQLCommand::Create);
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "DESCRIBE TABLE Cookies;");
EXPECT_EQ(result.size(), 12u);
@ -850,7 +846,7 @@ TEST_CASE(delete_single_row)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -863,7 +859,7 @@ TEST_CASE(delete_single_row)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
execute(database, "DELETE FROM TestSchema.TestTable WHERE (IntColumn = 4);");
@ -877,7 +873,7 @@ TEST_CASE(delete_single_row)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT_EQ(result.size(), 9u);
@ -894,7 +890,7 @@ TEST_CASE(delete_multiple_rows)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -907,7 +903,7 @@ TEST_CASE(delete_multiple_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
execute(database, "DELETE FROM TestSchema.TestTable WHERE (IntColumn >= 4);");
@ -919,7 +915,7 @@ TEST_CASE(delete_multiple_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT_EQ(result.size(), 4u);
@ -934,7 +930,7 @@ TEST_CASE(delete_all_rows)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -947,7 +943,7 @@ TEST_CASE(delete_all_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
execute(database, "DELETE FROM TestSchema.TestTable;");
@ -956,7 +952,7 @@ TEST_CASE(delete_all_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT * FROM TestSchema.TestTable;");
EXPECT(result.is_empty());
@ -968,7 +964,7 @@ TEST_CASE(update_single_row)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -992,7 +988,7 @@ TEST_CASE(update_single_row)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT_EQ(result.size(), 10u);
@ -1013,7 +1009,7 @@ TEST_CASE(update_multiple_rows)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -1035,7 +1031,7 @@ TEST_CASE(update_multiple_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT_EQ(result.size(), 10u);
@ -1054,7 +1050,7 @@ TEST_CASE(update_all_rows)
ScopeGuard guard([]() { unlink(db_name); });
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
create_table(database);
for (auto count = 0; count < 10; ++count) {
@ -1072,7 +1068,7 @@ TEST_CASE(update_all_rows)
}
{
auto database = SQL::Database::construct(db_name);
EXPECT(!database->open().is_error());
MUST(database->open());
auto result = execute(database, "SELECT IntColumn FROM TestSchema.TestTable ORDER BY IntColumn;");
EXPECT_EQ(result.size(), 10u);

64
Tests/LibSQL/TestSqlStatementParser.cpp
View file

@ -66,12 +66,7 @@ TEST_CASE(create_table)
};
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, Vector<Column> expected_columns, bool expected_is_temporary = false, bool expected_is_error_if_table_exists = true) {
auto result = parse(sql);
if (result.is_error())
outln("{}: {}", sql, result.error());
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::CreateTable>(*statement));
const auto& table = static_cast<const SQL::AST::CreateTable&>(*statement);
@ -147,10 +142,7 @@ TEST_CASE(alter_table_rename_table)
EXPECT(parse("ALTER TABLE table_name RENAME TO new_table"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_new_table) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::RenameTable>(*statement));
const auto& alter = static_cast<const SQL::AST::RenameTable&>(*statement);
@ -175,10 +167,7 @@ TEST_CASE(alter_table_rename_column)
EXPECT(parse("ALTER TABLE table_name RENAME column_name TO new_column"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column, StringView expected_new_column) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::RenameColumn>(*statement));
const auto& alter = static_cast<const SQL::AST::RenameColumn&>(*statement);
@ -207,10 +196,7 @@ TEST_CASE(alter_table_add_column)
};
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, Column expected_column) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::AddColumn>(*statement));
const auto& alter = static_cast<const SQL::AST::AddColumn&>(*statement);
@ -254,10 +240,7 @@ TEST_CASE(alter_table_drop_column)
EXPECT(parse("ALTER TABLE table_name DROP COLUMN column_name"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_column) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::DropColumn>(*statement));
const auto& alter = static_cast<const SQL::AST::DropColumn&>(*statement);
@ -280,10 +263,7 @@ TEST_CASE(drop_table)
EXPECT(parse("DROP TABLE IF test;"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, bool expected_is_error_if_table_does_not_exist = true) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::DropTable>(*statement));
const auto& table = static_cast<const SQL::AST::DropTable&>(*statement);
@ -321,10 +301,7 @@ TEST_CASE(insert)
EXPECT(parse("INSERT OR foo INTO table_name DEFAULT VALUES;"sv).is_error());
auto validate = [](StringView sql, SQL::AST::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<StringView> expected_column_names, Vector<size_t> expected_chain_sizes, bool expect_select_statement) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Insert>(*statement));
const auto& insert = static_cast<const SQL::AST::Insert&>(*statement);
@ -417,10 +394,7 @@ TEST_CASE(update)
EXPECT(parse("UPDATE OR foo table_name SET column_name=4;"sv).is_error());
auto validate = [](StringView sql, SQL::AST::ConflictResolution expected_conflict_resolution, StringView expected_schema, StringView expected_table, StringView expected_alias, Vector<Vector<DeprecatedString>> expected_update_columns, bool expect_where_clause, bool expect_returning_clause, Vector<StringView> expected_returned_column_aliases) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Update>(*statement));
const auto& update = static_cast<const SQL::AST::Update&>(*statement);
@ -514,10 +488,7 @@ TEST_CASE(delete_)
EXPECT(parse("DELETE FROM table_name WHERE (');"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table, StringView expected_alias, bool expect_where_clause, bool expect_returning_clause, Vector<StringView> expected_returned_column_aliases) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Delete>(*statement));
const auto& delete_ = static_cast<const SQL::AST::Delete&>(*statement);
@ -613,10 +584,7 @@ TEST_CASE(select)
};
auto validate = [](StringView sql, Vector<Type> expected_columns, Vector<From> expected_from_list, bool expect_where_clause, size_t expected_group_by_size, bool expect_having_clause, Vector<Ordering> expected_ordering, bool expect_limit_clause, bool expect_offset_clause) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Select>(*statement));
const auto& select = static_cast<const SQL::AST::Select&>(*statement);
@ -752,10 +720,7 @@ TEST_CASE(common_table_expression)
};
auto validate = [](StringView sql, SelectedTableList expected_selected_tables) {
auto result = parse(sql);
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::Delete>(*statement));
const auto& delete_ = static_cast<const SQL::AST::Delete&>(*statement);
@ -807,12 +772,7 @@ TEST_CASE(describe_table)
EXPECT(parse("DESCRIBE table_name;"sv).is_error());
auto validate = [](StringView sql, StringView expected_schema, StringView expected_table) {
auto result = parse(sql);
if (result.is_error())
outln("{}: {}", sql, result.error());
EXPECT(!result.is_error());
auto statement = result.release_value();
auto statement = TRY_OR_FAIL(parse(sql));
EXPECT(is<SQL::AST::DescribeTable>(*statement));
const auto& describe_table_statement = static_cast<const SQL::AST::DescribeTable&>(*statement);

32
Tests/LibSQL/TestSqlValueAndTuple.cpp
View file

@ -688,7 +688,6 @@ TEST_CASE(add)
SQL::Value value2 { 42 };
auto result = value1.add(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 63);
}
@ -697,7 +696,6 @@ TEST_CASE(add)
SQL::Value value2 { static_cast<u8>(42) };
auto result = value1.add(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 63);
}
@ -706,7 +704,6 @@ TEST_CASE(add)
SQL::Value value2 { 42 };
auto result = value1.add(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 63);
}
@ -715,7 +712,6 @@ TEST_CASE(add)
SQL::Value value2 { 42 };
auto result = value1.add(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 63);
}
@ -724,7 +720,6 @@ TEST_CASE(add)
SQL::Value value2 { 42 };
auto result = value1.add(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
EXPECT((result.value().to_double().value() - 63.5) < NumericLimits<double>().epsilon());
}
@ -777,7 +772,6 @@ TEST_CASE(subtract)
SQL::Value value2 { 42 };
auto result = value1.subtract(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), -21);
}
@ -786,7 +780,6 @@ TEST_CASE(subtract)
SQL::Value value2 { static_cast<u8>(42) };
auto result = value1.subtract(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), -21);
}
@ -795,7 +788,6 @@ TEST_CASE(subtract)
SQL::Value value2 { 21 };
auto result = value1.subtract(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 21);
}
@ -804,7 +796,6 @@ TEST_CASE(subtract)
SQL::Value value2 { 42 };
auto result = value1.subtract(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), -21);
}
@ -813,7 +804,6 @@ TEST_CASE(subtract)
SQL::Value value2 { 42 };
auto result = value1.subtract(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
EXPECT((result.value().to_double().value() - 20.5) < NumericLimits<double>().epsilon());
}
@ -866,7 +856,6 @@ TEST_CASE(multiply)
SQL::Value value2 { 21 };
auto result = value1.multiply(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 42);
}
@ -875,7 +864,6 @@ TEST_CASE(multiply)
SQL::Value value2 { static_cast<u8>(21) };
auto result = value1.multiply(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 42);
}
@ -884,7 +872,6 @@ TEST_CASE(multiply)
SQL::Value value2 { 21 };
auto result = value1.multiply(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 42);
}
@ -893,7 +880,6 @@ TEST_CASE(multiply)
SQL::Value value2 { 21 };
auto result = value1.multiply(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 42);
}
@ -902,7 +888,6 @@ TEST_CASE(multiply)
SQL::Value value2 { 21 };
auto result = value1.multiply(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
EXPECT((result.value().to_double().value() - 52.5) < NumericLimits<double>().epsilon());
}
@ -955,7 +940,6 @@ TEST_CASE(divide)
SQL::Value value2 { -2 };
auto result = value1.divide(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), -21);
}
@ -964,7 +948,6 @@ TEST_CASE(divide)
SQL::Value value2 { static_cast<u8>(2) };
auto result = value1.divide(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 21);
}
@ -973,7 +956,6 @@ TEST_CASE(divide)
SQL::Value value2 { 2 };
auto result = value1.divide(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 21);
}
@ -982,7 +964,6 @@ TEST_CASE(divide)
SQL::Value value2 { 2 };
auto result = value1.divide(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 21);
}
@ -991,7 +972,6 @@ TEST_CASE(divide)
SQL::Value value2 { 2 };
auto result = value1.divide(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Float);
EXPECT((result.value().to_double().value() - 21.5) < NumericLimits<double>().epsilon());
}
@ -1026,7 +1006,6 @@ TEST_CASE(modulo)
SQL::Value value2 { 2 };
auto result = value1.modulo(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 1);
}
@ -1035,7 +1014,6 @@ TEST_CASE(modulo)
SQL::Value value2 { static_cast<u8>(2) };
auto result = value1.modulo(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 1);
}
@ -1044,7 +1022,6 @@ TEST_CASE(modulo)
SQL::Value value2 { 2 };
auto result = value1.modulo(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 1);
}
@ -1053,7 +1030,6 @@ TEST_CASE(modulo)
SQL::Value value2 { 2 };
auto result = value1.modulo(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 1);
}
@ -1115,7 +1091,6 @@ TEST_CASE(shift_left)
SQL::Value value2 { 2 };
auto result = value1.shift_left(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b1100'0000);
}
@ -1124,7 +1099,6 @@ TEST_CASE(shift_left)
SQL::Value value2 { static_cast<u8>(2) };
auto result = value1.shift_left(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b1100'0000);
}
@ -1133,7 +1107,6 @@ TEST_CASE(shift_left)
SQL::Value value2 { 2 };
auto result = value1.shift_left(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b1100'0000);
}
@ -1142,7 +1115,6 @@ TEST_CASE(shift_left)
SQL::Value value2 { 2 };
auto result = value1.shift_left(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b1100'0000);
}
@ -1213,7 +1185,6 @@ TEST_CASE(shift_right)
SQL::Value value2 { 2 };
auto result = value1.shift_right(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b0000'1100);
}
@ -1222,7 +1193,6 @@ TEST_CASE(shift_right)
SQL::Value value2 { static_cast<u8>(2) };
auto result = value1.shift_right(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b0000'1100);
}
@ -1231,7 +1201,6 @@ TEST_CASE(shift_right)
SQL::Value value2 { 2 };
auto result = value1.shift_right(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b0000'1100);
}
@ -1240,7 +1209,6 @@ TEST_CASE(shift_right)
SQL::Value value2 { 2 };
auto result = value1.shift_right(value2);
EXPECT(!result.is_error());
EXPECT_EQ(result.value().type(), SQL::SQLType::Integer);
EXPECT_EQ(result.value(), 0b0000'1100);
}