Skip to content

Commit cda4b89

Browse files
SRombautsSRombauts
committed
A few more unit tests for backups, statement and database
 - should get us to 100% on Backup
1 parent 69d9b08 commit cda4b89

File tree

3 files changed

+154
-11
lines changed

3 files changed

+154
-11
lines changed

‎tests/Backup_test.cpp

Lines changed: 44 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,8 @@
33
* @ingroup tests
44
* @brief Test of a SQLite Backup.
55
*
6-
* Copyright (c) 2015-2015 Shibao HONG (shibaohong@outlook.com)
6+
* Copyright (c) 2015 Shibao HONG (shibaohong@outlook.com)
7+
* Copyright (c) 2016 Sebastien Rombauts (sebastien.rombauts@gmail.com)
78
*
89
* Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt
910
* or copy at http://opensource.org/licenses/MIT)
@@ -24,11 +25,46 @@ TEST(Backup, initException) {
2425
srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)");
2526
ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")"));
2627
ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")"));
27-
EXPECT_THROW(SQLite::Backup backup(srcDB, "src", srcDB, "src"), SQLite::Exception);
28+
EXPECT_THROW(SQLite::Backup backup(srcDB, srcDB), SQLite::Exception);
29+
EXPECT_THROW(SQLite::Backup backup(srcDB, "main", srcDB, "main"), SQLite::Exception);
30+
const std::string name("main");
31+
EXPECT_THROW(SQLite::Backup backup(srcDB, name, srcDB, name), SQLite::Exception);
2832
remove("backup_test.db3");
2933
}
3034

31-
TEST(Backup, executeStep) {
35+
TEST(Backup, executeStepOne) {
36+
remove("backup_test.db3");
37+
remove("backup_test.db3.backup");
38+
SQLite::Database srcDB("backup_test.db3", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
39+
srcDB.exec("CREATE TABLE backup_test (id INTEGER PRIMARY KEY, value TEXT)");
40+
ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (1, \"first\")"));
41+
ASSERT_EQ(1, srcDB.exec("INSERT INTO backup_test VALUES (2, \"second\")"));
42+
43+
SQLite::Database destDB("backup_test.db3.backup", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
44+
SQLite::Backup backup(destDB, "main", srcDB, "main");
45+
int res = backup.executeStep(1); // backup only one page at a time
46+
ASSERT_EQ(SQLITE_OK, res);
47+
const int total = backup.totalPageCount();
48+
ASSERT_EQ(2, total);
49+
int remaining = backup.remainingPageCount();
50+
ASSERT_EQ(1, remaining);
51+
res = backup.executeStep(1); // backup the second and last page
52+
ASSERT_EQ(SQLITE_DONE, res);
53+
remaining = backup.remainingPageCount();
54+
ASSERT_EQ(0, remaining);
55+
56+
SQLite::Statement query(destDB, "SELECT * FROM backup_test ORDER BY id ASC");
57+
ASSERT_TRUE(query.executeStep());
58+
EXPECT_EQ(1, query.getColumn(0).getInt());
59+
EXPECT_STREQ("first", query.getColumn(1));
60+
ASSERT_TRUE(query.executeStep());
61+
EXPECT_EQ(2, query.getColumn(0).getInt());
62+
EXPECT_STREQ("second", query.getColumn(1));
63+
remove("backup_test.db3");
64+
remove("backup_test.db3.backup");
65+
}
66+
67+
TEST(Backup, executeStepAll) {
3268
remove("backup_test.db3");
3369
remove("backup_test.db3.backup");
3470
SQLite::Database srcDB("backup_test.db3", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
@@ -38,8 +74,12 @@ TEST(Backup, executeStep) {
3874

3975
SQLite::Database destDB("backup_test.db3.backup", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
4076
SQLite::Backup backup(destDB, srcDB);
41-
const int res = backup.executeStep();
77+
const int res = backup.executeStep(); // uses default argument "-1" => execute all steps at once
4278
ASSERT_EQ(res, SQLITE_DONE);
79+
const int total = backup.totalPageCount();
80+
ASSERT_EQ(2, total);
81+
const int remaining = backup.remainingPageCount();
82+
ASSERT_EQ(0, remaining);
4383

4484
SQLite::Statement query(destDB, "SELECT * FROM backup_test ORDER BY id ASC");
4585
ASSERT_TRUE(query.executeStep());

‎tests/Database_test.cpp

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ void assertion_failed(const char* apFile, const long apLine, const char* apFunc,
3131
TEST(Database, ctorExecCreateDropExist) {
3232
remove("test.db3");
3333
{
34-
// Try to open an unexisting database
34+
// Try to open a non-existing database
3535
std::string filename = "test.db3";
3636
EXPECT_THROW(SQLite::Database not_found(filename), SQLite::Exception);
3737

@@ -58,7 +58,7 @@ TEST(Database, ctorExecCreateDropExist) {
5858
TEST(Database, createCloseReopen) {
5959
remove("test.db3");
6060
{
61-
// Try to open the unexisting database
61+
// Try to open the non-existing database
6262
EXPECT_THROW(SQLite::Database not_found("test.db3"), SQLite::Exception);
6363

6464
// Create a new database
@@ -153,7 +153,8 @@ TEST(Database, exec) {
153153
EXPECT_EQ(2, db.getTotalChanges());
154154

155155
// third row : insert the "third" text value into new row of id 3
156-
EXPECT_EQ(1, db.exec("INSERT INTO test VALUES (NULL, \"third\")"));
156+
const std::string insert("INSERT INTO test VALUES (NULL, \"third\")");
157+
EXPECT_EQ(1, db.exec(insert));
157158
EXPECT_EQ(3, db.getLastInsertRowid());
158159
EXPECT_EQ(3, db.getTotalChanges());
159160

‎tests/Statement_test.cpp

Lines changed: 106 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ TEST(Statement, invalid) {
3333
EXPECT_EQ(SQLITE_OK, db.getExtendedErrorCode());
3434

3535
// Compile a SQL query with no parameter
36-
SQLite::Statement query(db, "SELECT * FROM test");
36+
SQLite::Statement query(db, "SELECT * FROM test");
3737
EXPECT_STREQ("SELECT * FROM test", query.getQuery().c_str());
3838
EXPECT_EQ(2, query.getColumnCount ());
3939
EXPECT_FALSE(query.isOk());
@@ -86,6 +86,108 @@ TEST(Statement, invalid) {
8686

8787
// TODO: test every kind of binding + clearBindings()
8888

89+
TEST(Statement, executeStep) {
90+
// Create a new database
91+
SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
92+
EXPECT_EQ(SQLITE_OK, db.getErrorCode());
93+
94+
// Create a new table
95+
EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT, int INTEGER, double REAL)"));
96+
EXPECT_EQ(SQLITE_OK, db.getErrorCode());
97+
98+
// Create a first row
99+
EXPECT_EQ(1, db.exec("INSERT INTO test VALUES (NULL, \"first\", 123, 0.123)"));
100+
EXPECT_EQ(1, db.getLastInsertRowid());
101+
102+
// Compile a SQL query
103+
SQLite::Statement query(db, "SELECT * FROM test");
104+
EXPECT_STREQ("SELECT * FROM test", query.getQuery().c_str());
105+
EXPECT_EQ(4, query.getColumnCount());
106+
107+
// Get the first row
108+
query.executeStep();
109+
EXPECT_TRUE (query.isOk());
110+
EXPECT_FALSE(query.isDone());
111+
const sqlite3_int64 id = query.getColumn(0);
112+
const std::string msg = query.getColumn(1);
113+
const int integer = query.getColumn(2);
114+
const double real = query.getColumn(3);
115+
EXPECT_EQ(1, id);
116+
EXPECT_EQ("first", msg);
117+
EXPECT_EQ(123, integer);
118+
EXPECT_EQ(0.123, real);
119+
120+
// Step one more time to discover there is nothing more
121+
query.executeStep();
122+
EXPECT_FALSE(query.isOk());
123+
EXPECT_TRUE (query.isDone()); // "done" is "the end"
124+
125+
// Step after "the end" throw an exception
126+
EXPECT_THROW(query.executeStep(), SQLite::Exception);
127+
}
128+
129+
TEST(Statement, isColumnNull) {
130+
// Create a new database
131+
SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
132+
ASSERT_EQ(SQLITE_OK, db.getErrorCode());
133+
134+
// Create a new table
135+
EXPECT_EQ(0, db.exec("CREATE TABLE test (msg TEXT, int INTEGER, double REAL)"));
136+
ASSERT_EQ(SQLITE_OK, db.getErrorCode());
137+
138+
// Create a first row with no null values, then other rows with each time a NULL value
139+
ASSERT_EQ(1, db.exec("INSERT INTO test VALUES (\"first\", 123, 0.123)"));
140+
ASSERT_EQ(1, db.exec("INSERT INTO test VALUES (NULL, 123, 0.123)"));
141+
ASSERT_EQ(1, db.exec("INSERT INTO test VALUES (\"first\", NULL, 0.123)"));
142+
ASSERT_EQ(1, db.exec("INSERT INTO test VALUES (\"first\", 123, NULL)"));
143+
144+
// Compile a SQL query
145+
const std::string select("SELECT * FROM test");
146+
SQLite::Statement query(db, select);
147+
EXPECT_EQ(select, query.getQuery());
148+
EXPECT_EQ(3, query.getColumnCount());
149+
150+
// Get the first non-null row
151+
query.executeStep();
152+
EXPECT_TRUE (query.isOk());
153+
EXPECT_FALSE(query.isDone());
154+
EXPECT_THROW(query.isColumnNull(-1), SQLite::Exception);
155+
EXPECT_EQ(false, query.isColumnNull(0));
156+
EXPECT_EQ(false, query.isColumnNull(1));
157+
EXPECT_EQ(false, query.isColumnNull(2));
158+
EXPECT_THROW(query.isColumnNull(3), SQLite::Exception);
159+
160+
// Get the second row with null text
161+
query.executeStep();
162+
EXPECT_TRUE (query.isOk());
163+
EXPECT_FALSE(query.isDone());
164+
EXPECT_THROW(query.isColumnNull(-1), SQLite::Exception);
165+
EXPECT_EQ(true, query.isColumnNull(0));
166+
EXPECT_EQ(false, query.isColumnNull(1));
167+
EXPECT_EQ(false, query.isColumnNull(2));
168+
EXPECT_THROW(query.isColumnNull(3), SQLite::Exception);
169+
170+
// Get the second row with null integer
171+
query.executeStep();
172+
EXPECT_TRUE (query.isOk());
173+
EXPECT_FALSE(query.isDone());
174+
EXPECT_THROW(query.isColumnNull(-1), SQLite::Exception);
175+
EXPECT_EQ(false, query.isColumnNull(0));
176+
EXPECT_EQ(true, query.isColumnNull(1));
177+
EXPECT_EQ(false, query.isColumnNull(2));
178+
EXPECT_THROW(query.isColumnNull(3), SQLite::Exception);
179+
180+
// Get the third row with null float
181+
query.executeStep();
182+
EXPECT_TRUE (query.isOk());
183+
EXPECT_FALSE(query.isDone());
184+
EXPECT_THROW(query.isColumnNull(-1), SQLite::Exception);
185+
EXPECT_EQ(false, query.isColumnNull(0));
186+
EXPECT_EQ(false, query.isColumnNull(1));
187+
EXPECT_EQ(true, query.isColumnNull(2));
188+
EXPECT_THROW(query.isColumnNull(3), SQLite::Exception);
189+
}
190+
89191
TEST(Statement, getColumnByName) {
90192
// Create a new database
91193
SQLite::Database db(":memory:", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
@@ -103,14 +205,14 @@ TEST(Statement, getColumnByName) {
103205
EXPECT_EQ(1, db.getTotalChanges());
104206

105207
// Compile a SQL query
106-
SQLite::Statement query(db, "SELECT * FROM test");
208+
SQLite::Statement query(db, "SELECT * FROM test");
107209
EXPECT_STREQ("SELECT * FROM test", query.getQuery().c_str());
108210
EXPECT_EQ(4, query.getColumnCount());
109211
query.executeStep();
110212
EXPECT_TRUE (query.isOk());
111213
EXPECT_FALSE(query.isDone());
112214

113-
// Look for unexisting columns
215+
// Look for non-existing columns
114216
EXPECT_THROW(query.getColumn("unknown"), SQLite::Exception);
115217
EXPECT_THROW(query.getColumn(""), SQLite::Exception);
116218

@@ -128,7 +230,7 @@ TEST(Statement, getName) {
128230
EXPECT_EQ(0, db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, msg TEXT)"));
129231

130232
// Compile a SQL query, using the "id" column name as-is, but aliasing the "msg" column with new name "value"
131-
SQLite::Statement query(db, "SELECT id, msg as value FROM test");
233+
SQLite::Statement query(db, "SELECT id, msg as value FROM test");
132234
query.executeStep();
133235

134236
const std::string name0 = query.getColumnName(0);

0 commit comments

Comments
 (0)