From ddb4929ddb8ba8544a2eb860598291431b7c40b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Rombauts?= Date: Sat, 4 Jan 2020 19:10:23 +0100 Subject: [PATCH] Fix and improve read-header unit tests, as well as backup tests --- tests/Backup_test.cpp | 130 +++++++++++++++++++++------------------- tests/Database_test.cpp | 51 +++++++++++----- 2 files changed, 104 insertions(+), 77 deletions(-) diff --git a/tests/Backup_test.cpp b/tests/Backup_test.cpp index 9770895..1b28542 100644 --- a/tests/Backup_test.cpp +++ b/tests/Backup_test.cpp @@ -24,14 +24,16 @@ TEST(Backup, initException) { remove("backup_test.db3"); - SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); - srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); - ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); - ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); - EXPECT_THROW(SQLite::Backup backup(srcDB, srcDB), SQLite::Exception); - EXPECT_THROW(SQLite::Backup backup(srcDB, "main", srcDB, "main"), SQLite::Exception); - const std::string name("main"); - EXPECT_THROW(SQLite::Backup backup(srcDB, name, srcDB, name), SQLite::Exception); + { + SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); + ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); + ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); + EXPECT_THROW(SQLite::Backup backup(srcDB, srcDB), SQLite::Exception); + EXPECT_THROW(SQLite::Backup backup(srcDB, "main", srcDB, "main"), SQLite::Exception); + const std::string name("main"); + EXPECT_THROW(SQLite::Backup backup(srcDB, name, srcDB, name), SQLite::Exception); + } remove("backup_test.db3"); } @@ -39,31 +41,33 @@ TEST(Backup, executeStepOne) { remove("backup_test.db3"); remove("backup_test.db3.backup"); - SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); - srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); - ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); - ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); + { + SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); + ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); + ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); - SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); - SQLite::Backup backup(destDB, "main", srcDB, "main"); - int res = backup.executeStep(1); // backup only one page at a time - ASSERT_EQ(SQLite::OK, res); - const int total = backup.getTotalPageCount(); - ASSERT_EQ(2, total); - int remaining = backup.getRemainingPageCount(); - ASSERT_EQ(1, remaining); - res = backup.executeStep(1); // backup the second and last page - ASSERT_EQ(SQLITE_DONE, res); - remaining = backup.getRemainingPageCount(); - ASSERT_EQ(0, remaining); + SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + SQLite::Backup backup(destDB, "main", srcDB, "main"); + int res = backup.executeStep(1); // backup only one page at a time + ASSERT_EQ(SQLite::OK, res); + const int total = backup.getTotalPageCount(); + ASSERT_EQ(2, total); + int remaining = backup.getRemainingPageCount(); + ASSERT_EQ(1, remaining); + res = backup.executeStep(1); // backup the second and last page + ASSERT_EQ(SQLITE_DONE, res); + remaining = backup.getRemainingPageCount(); + ASSERT_EQ(0, remaining); - SQLite::Statement query(destDB, "SELECT * FROM backup_test ORDER BY id ASC"); - ASSERT_TRUE(query.executeStep()); - EXPECT_EQ(1, query.getColumn(0).getInt()); - EXPECT_STREQ("first", query.getColumn(1)); - ASSERT_TRUE(query.executeStep()); - EXPECT_EQ(2, query.getColumn(0).getInt()); - EXPECT_STREQ("second", query.getColumn(1)); + SQLite::Statement query(destDB, "SELECT * FROM backup_test ORDER BY id ASC"); + ASSERT_TRUE(query.executeStep()); + EXPECT_EQ(1, query.getColumn(0).getInt()); + EXPECT_STREQ("first", query.getColumn(1)); + ASSERT_TRUE(query.executeStep()); + EXPECT_EQ(2, query.getColumn(0).getInt()); + EXPECT_STREQ("second", query.getColumn(1)); + } remove("backup_test.db3"); remove("backup_test.db3.backup"); } @@ -72,27 +76,29 @@ TEST(Backup, executeStepAll) { remove("backup_test.db3"); remove("backup_test.db3.backup"); - SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); - srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); - ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); - ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); + { + SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); + ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); + ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); - SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); - SQLite::Backup backup(destDB, srcDB); - const int res = backup.executeStep(); // uses default argument "-1" => execute all steps at once - ASSERT_EQ(res, SQLITE_DONE); - const int total = backup.getTotalPageCount(); - ASSERT_EQ(2, total); - const int remaining = backup.getRemainingPageCount(); - ASSERT_EQ(0, remaining); + SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + SQLite::Backup backup(destDB, srcDB); + const int res = backup.executeStep(); // uses default argument "-1" => execute all steps at once + ASSERT_EQ(res, SQLITE_DONE); + const int total = backup.getTotalPageCount(); + ASSERT_EQ(2, total); + const int remaining = backup.getRemainingPageCount(); + ASSERT_EQ(0, remaining); - SQLite::Statement query(destDB, "SELECT * FROM backup_test ORDER BY id ASC"); - ASSERT_TRUE(query.executeStep()); - EXPECT_EQ(1, query.getColumn(0).getInt()); - EXPECT_STREQ("first", query.getColumn(1)); - ASSERT_TRUE(query.executeStep()); - EXPECT_EQ(2, query.getColumn(0).getInt()); - EXPECT_STREQ("second", query.getColumn(1)); + SQLite::Statement query(destDB, "SELECT * FROM backup_test ORDER BY id ASC"); + ASSERT_TRUE(query.executeStep()); + EXPECT_EQ(1, query.getColumn(0).getInt()); + EXPECT_STREQ("first", query.getColumn(1)); + ASSERT_TRUE(query.executeStep()); + EXPECT_EQ(2, query.getColumn(0).getInt()); + EXPECT_STREQ("second", query.getColumn(1)); + } remove("backup_test.db3"); remove("backup_test.db3.backup"); } @@ -101,18 +107,20 @@ TEST(Backup, executeStepException) { remove("backup_test.db3"); remove("backup_test.db3.backup"); - SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); - srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); - ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); - ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); { - SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); - (void)destDB; - } - { - SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READONLY); - SQLite::Backup backup(destDB, srcDB); - EXPECT_THROW(backup.executeStep(), SQLite::Exception); + SQLite::Database srcDB("backup_test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)"); + ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")")); + ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")")); + { + SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + (void)destDB; + } + { + SQLite::Database destDB("backup_test.db3.backup", SQLite::OPEN_READONLY); + SQLite::Backup backup(destDB, srcDB); + EXPECT_THROW(backup.executeStep(), SQLite::Exception); + } } remove("backup_test.db3"); remove("backup_test.db3.backup"); diff --git a/tests/Database_test.cpp b/tests/Database_test.cpp index 102fac6..93dc205 100644 --- a/tests/Database_test.cpp +++ b/tests/Database_test.cpp @@ -140,15 +140,16 @@ TEST(Database, backup) EXPECT_TRUE(db.tableExists("test")); // Export the data into a file - remove("backup"); - EXPECT_NO_THROW(db.backup("backup", SQLite::Database::Save)); + remove("backup.db3"); + EXPECT_NO_THROW(db.backup("backup.db3", SQLite::Database::Save)); // Trash the table db.exec("DROP TABLE test;"); EXPECT_FALSE(db.tableExists("test")); // Import the data back from the file - EXPECT_NO_THROW(db.backup("backup", SQLite::Database::Load)); + EXPECT_NO_THROW(db.backup("backup.db3", SQLite::Database::Load)); + remove("backup.db3"); EXPECT_TRUE(db.tableExists("test")); } @@ -359,28 +360,46 @@ TEST(Database, getHeaderInfo) { remove("test.db3"); { - //Call without passing a database file name + // Call without passing a database file name EXPECT_THROW(SQLite::Database::getHeaderInfo(""),SQLite::Exception); - //Call with a non existant database + // Call with a non-existent database EXPECT_THROW(SQLite::Database::getHeaderInfo("test.db3"), SQLite::Exception); - //Simulate a corrupt header by writing garbage to a file - unsigned char badData[100]; - char* pBadData = reinterpret_cast(&badData[0]); + // Simulate an incomplete header by writing garbage to a file + { + const unsigned char badData[] = "garbage..."; + const char* pBadData = reinterpret_cast(&badData[0]); - std::ofstream corruptDb; - corruptDb.open("corrupt.db3", std::ios::app | std::ios::binary); - corruptDb.write(pBadData, 100); + remove("short.db3"); + std::ofstream corruptDb; + corruptDb.open("short.db3", std::ios::app | std::ios::binary); + corruptDb.write(pBadData, sizeof(badData)); + corruptDb.close(); - EXPECT_THROW(SQLite::Database::getHeaderInfo("corrupt.db3"), SQLite::Exception); - - remove("corrupt.db3"); + EXPECT_THROW(SQLite::Database::getHeaderInfo("short.db3"), SQLite::Exception); + remove("short.db3"); + } + + // Simulate a corrupt header by writing garbage to a file + { + const unsigned char badData[100] = "garbage..."; + const char* pBadData = reinterpret_cast(&badData[0]); + + remove("corrupt.db3"); + std::ofstream corruptDb; + corruptDb.open("corrupt.db3", std::ios::app | std::ios::binary); + corruptDb.write(pBadData, sizeof(badData)); + corruptDb.close(); + + EXPECT_THROW(SQLite::Database::getHeaderInfo("corrupt.db3"), SQLite::Exception); + remove("corrupt.db3"); + } // Create a new database SQLite::Database db("test.db3", SQLite::OPEN_READWRITE | SQLite::OPEN_CREATE); db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)"); - + // Set assorted SQLite header values using associated PRAGMA db.exec("PRAGMA main.user_version = 12345"); db.exec("PRAGMA main.application_id = 2468"); @@ -388,7 +407,7 @@ TEST(Database, getHeaderInfo) // Parse header fields from test database SQLite::Header h = SQLite::Database::getHeaderInfo("test.db3"); - //Test header values expliticly set via PRAGMA statements + //Test header values explicitly set via PRAGMA statements EXPECT_EQ(h.userVersion, 12345); EXPECT_EQ(h.applicationId, 2468);