1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <gtest/gtest.h>
16 #include <sys/stat.h>
17 #include <sys/types.h>
18
19 #include <chrono>
20 #include <cstdio>
21 #include <fcntl.h>
22 #include <fstream>
23 #include <random>
24 #include <string>
25 #include <unistd.h>
26 #include <sstream>
27 #include <vector>
28
29 #include "common.h"
30 #include "sqlite3sym.h"
31
32 using namespace testing::ext;
33 using namespace UnitTest::SQLiteTest;
34
35 #define TEST_DIR "./sqlitecksumtest"
36 #define TEST_DB (TEST_DIR "/test.db")
37 #define TEST_PRESET_TABLE_COUNT 20
38 #define TEST_PRESET_DATA_COUNT 1000
39 #define TEST_DATA_REAL (16.1)
40
41 namespace Test {
42 class SQLiteCksumTest : public testing::Test {
43 public:
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
46 void SetUp();
47 void TearDown();
48
49 static void UtSqliteLogPrint(void *data, int err, const char *msg);
50 static void UtBackupDatabase(sqlite3 *srcDb, sqlite3 *destDb);
51 static void UtPresetDb(const std::string &dbFile, const std::string &vfsStr);
52 static int UtSqliteExecCallback(void *data, int argc, char **argv, char **azColName);
53 static bool IsSupportPageCheck(void);
54 static int hitCksmFault_;
55 };
56
57 int SQLiteCksumTest::hitCksmFault_ = 0;
58
SetUpTestCase(void)59 void SQLiteCksumTest::SetUpTestCase(void)
60 {
61 Common::RemoveDir(TEST_DIR);
62 Common::MakeDir(TEST_DIR);
63 }
64
TearDownTestCase(void)65 void SQLiteCksumTest::TearDownTestCase(void)
66 {
67 }
68
SetUp(void)69 void SQLiteCksumTest::SetUp(void)
70 {
71 sqlite3_config(SQLITE_CONFIG_LOG, &SQLiteCksumTest::UtSqliteLogPrint, nullptr);
72 EXPECT_EQ(sqlite3_register_cksumvfs(NULL), SQLITE_OK);
73 }
74
TearDown(void)75 void SQLiteCksumTest::TearDown(void)
76 {
77 EXPECT_EQ(sqlite3_unregister_cksumvfs(), SQLITE_OK);
78 sqlite3_config(SQLITE_CONFIG_LOG, NULL, NULL);
79 }
80
UtSqliteLogPrint(void * data,int err,const char * msg)81 void SQLiteCksumTest::UtSqliteLogPrint(void *data, int err, const char *msg)
82 {
83 std::string errStr = msg;
84 if (errStr.find("checksum fault") != std::string::npos) {
85 std::cout << "Hit checksum fault!!!" << std::endl;
86 hitCksmFault_++;
87 }
88 std::cout << "SQLiteCksumTest xLog err:" << err << ", msg:" << msg << std::endl;
89 }
90
UtSqliteExecCallback(void * data,int argc,char ** argv,char ** azColName)91 int SQLiteCksumTest::UtSqliteExecCallback(void *data, int argc, char **argv, char **azColName)
92 {
93 std::cout << (const char *)data << " result:" << std::endl;
94 for (int i = 0; i < argc; i++) {
95 std::cout << azColName[i] << " = " << (argv[i] ? argv[i] : "NULL") << std::endl;
96 }
97 std::cout <<std::endl;
98 return 0;
99 }
100
UtBackupDatabase(sqlite3 * srcDb,sqlite3 * destDb)101 void SQLiteCksumTest::UtBackupDatabase(sqlite3 *srcDb, sqlite3 *destDb)
102 {
103 sqlite3_backup *back = nullptr;
104 back = sqlite3_backup_init(destDb, "main", srcDb, "main");
105 EXPECT_TRUE(back != nullptr);
106 EXPECT_EQ(sqlite3_backup_step(back, -1), SQLITE_DONE);
107 sqlite3_backup_finish(back);
108 }
109
UtPresetDb(const std::string & dbFile,const std::string & vfsStr)110 void SQLiteCksumTest::UtPresetDb(const std::string &dbFile, const std::string &vfsStr)
111 {
112 /**
113 * @tc.steps: step1. Prepare db used to simulate corrupted
114 * @tc.expected: step1. Execute successfully
115 */
116 sqlite3 *db = NULL;
117 std::string dbFileUri = vfsStr.empty() ? "" : "file:";
118 dbFileUri += dbFile;
119 if (vfsStr.empty()) {
120 dbFileUri += "";
121 } else {
122 dbFileUri += "?vfs=";
123 dbFileUri += vfsStr;
124 }
125 EXPECT_EQ(sqlite3_open(dbFileUri.c_str(), &db), SQLITE_OK);
126 /**
127 * @tc.steps: step1. Enable cksumvfs using PRAGMA checksum_persist_enable,
128 * @tc.expected: step1. Execute successfully
129 */
130 if (!vfsStr.empty()) {
131 EXPECT_EQ(sqlite3_exec(db, "PRAGMA checksum_persist_enable=ON;", NULL, NULL, NULL), SQLITE_OK);
132 }
133 EXPECT_EQ(sqlite3_exec(db, "PRAGMA meta_double_write=enabled;", NULL, NULL, NULL), SQLITE_OK);
134 EXPECT_EQ(sqlite3_exec(db, "PRAGMA journal_mode=WAL;", NULL, NULL, NULL), SQLITE_OK);
135 /**
136 * @tc.steps: step1. Create table and fill it, make db size big enough
137 * @tc.expected: step1. Execute successfully
138 */
139 static const char *UT_DDL_CREATE_TABLE = "CREATE TABLE salary("
140 "entryId INTEGER PRIMARY KEY,"
141 "entryName Text,"
142 "salary REAL,"
143 "class INTEGER);";
144 EXPECT_EQ(sqlite3_exec(db, UT_DDL_CREATE_TABLE, NULL, NULL, NULL), SQLITE_OK);
145 std::string tmp = "CREATE TABLE test";
146 for (size_t i = 0; i < TEST_PRESET_TABLE_COUNT; i++) {
147 std::string ddl = "CREATE TABLE test";
148 ddl += std::to_string(i);
149 ddl += "(entryId INTEGER PRIMARY KEY,entryName Text,salary REAL,class INTEGER);";
150 EXPECT_EQ(sqlite3_exec(db, ddl.c_str(), NULL, NULL, NULL), SQLITE_OK);
151 }
152 static const char *UT_SQL_INSERT_DATA = "INSERT INTO salary(entryId, entryName, salary, class) VALUES(?,?,?,?);";
153 sqlite3_stmt *insertStmt = NULL;
154 EXPECT_EQ(sqlite3_prepare_v2(db, UT_SQL_INSERT_DATA, -1, &insertStmt, NULL), SQLITE_OK);
155 for (int i = 0; i < TEST_PRESET_DATA_COUNT; i++) {
156 // bind parameters, 1, 2, 3, 4 are sequence number of fields
157 sqlite3_bind_int(insertStmt, 1, i + 1);
158 sqlite3_bind_text(insertStmt, 2, "salary-entry-name", -1, SQLITE_STATIC);
159 sqlite3_bind_double(insertStmt, 3, TEST_DATA_REAL + i);
160 sqlite3_bind_int(insertStmt, 4, i + 1);
161 EXPECT_EQ(sqlite3_step(insertStmt), SQLITE_DONE);
162 sqlite3_reset(insertStmt);
163 }
164 sqlite3_finalize(insertStmt);
165 sqlite3_close(db);
166 }
167
IsSupportPageCheck(void)168 bool SQLiteCksumTest::IsSupportPageCheck(void)
169 {
170 #ifdef SQLITE_SUPPORT_PAGE_CHECK_TEST
171 return true;
172 #else
173 return false;
174 #endif
175 }
176
177 /**
178 * @tc.name: CksumTest001
179 * @tc.desc: Test to enable cksum before backup
180 * @tc.type: FUNC
181 */
182 HWTEST_F(SQLiteCksumTest, CksumTest001, TestSize.Level0)
183 {
184 /**
185 * @tc.steps: step1. Create a new db as main, disable cksum
186 * @tc.expected: step1. Execute successfully
187 */
188 std::string dbPath = TEST_DIR "/test001.db";
189 UtPresetDb(dbPath, "");
190 sqlite3 *db = nullptr;
191 EXPECT_EQ(sqlite3_open(dbPath.c_str(), &db),SQLITE_OK);
192
193 /**
194 * @tc.steps: step2. Create a new db as slave, enable cksum
195 * @tc.expected: step2. Execute successfully
196 */
197 std::string slaveDbPath = TEST_DIR "/test001_slave.db";
198 sqlite3 *slaveDb = nullptr;
199 std::string dbFileUri = "file:";
200 dbFileUri += slaveDbPath;
201 dbFileUri += "?vfs=cksmvfs";
202 EXPECT_EQ(sqlite3_open(dbFileUri.c_str(), &slaveDb),SQLITE_OK);
203 EXPECT_EQ(sqlite3_exec(slaveDb, "PRAGMA checksum_persist_enable=ON;", NULL, NULL, NULL), SQLITE_OK);
204 EXPECT_EQ(sqlite3_exec(slaveDb, "PRAGMA meta_double_write=enabled;", NULL, NULL, NULL), SQLITE_OK);
205 EXPECT_EQ(sqlite3_exec(slaveDb, "PRAGMA journal_mode=WAL;", NULL, NULL, NULL), SQLITE_OK);
206 UtBackupDatabase(db, slaveDb);
207 sqlite3_close(slaveDb);
208 sqlite3_close(db);
209 /**
210 * @tc.steps: step3. Open slave db, make an integrity check
211 * @tc.expected: step3. Execute successfully
212 */
213 EXPECT_EQ(sqlite3_open(dbFileUri.c_str(), &slaveDb),SQLITE_OK);
214 EXPECT_EQ(sqlite3_exec(slaveDb, "PRAGMA integrity_check;", UtSqliteExecCallback, (void *)"PRAGMA", nullptr),
215 SQLITE_OK);
216 sqlite3_close(slaveDb);
217 }
218
UtQueryResult(void * data,int argc,char ** argv,char ** azColName)219 static int UtQueryResult(void *data, int argc, char **argv, char **azColName)
220 {
221 int count = *static_cast<int *>(data);
222 *static_cast<int *>(data) = count + 1;
223 // 2 means 2 fields, entryId, entryName
224 EXPECT_EQ(argc, 2);
225 return SQLITE_OK;
226 }
227
UtDestroyFile(const std::string & dbPath,int offset,const std::string replaceStr)228 static void UtDestroyFile(const std::string &dbPath, int offset, const std::string replaceStr)
229 {
230 int fd = open(dbPath.c_str(), O_WRONLY | O_CREAT);
231 lseek(fd, offset, SEEK_SET);
232 write(fd, replaceStr.c_str(), replaceStr.size());
233 close(fd);
234 }
235
236 /**
237 * @tc.name: CksumTest002
238 * @tc.desc: Test to enable cksum on compress db
239 * @tc.type: FUNC
240 */
241 HWTEST_F(SQLiteCksumTest, CksumTest002, TestSize.Level0)
242 {
243 if (!IsSupportPageCheck()) {
244 GTEST_SKIP() << "Current testcase is not compatible";
245 }
246 /**
247 * @tc.steps: step1. Create a new db as main, enable compress
248 * @tc.expected: step1. Execute successfully
249 */
250 std::string dbPath = TEST_DIR "/test002.db";
251 UtPresetDb(dbPath, "compressvfs");
252 /**
253 * @tc.steps: step2. Destory the db file to simulate corrupted
254 * @tc.expected: step2. Execute successfully
255 */
256 // 2 * 4096 + 512 means the corrupted position, which locate on the third page, 512 bytes offset
257 UtDestroyFile(dbPath, 2 * 4096 + 512, "123");
258 /**
259 * @tc.steps: step3. Reverse the table to get the info, check log info, should print "checksum fault"
260 * @tc.expected: step3. Execute successfully
261 */
262 hitCksmFault_ = 0;
263 sqlite3 *db = nullptr;
264 EXPECT_EQ(sqlite3_open_v2(dbPath.c_str(), &db, SQLITE_OPEN_READWRITE, "compressvfs"), SQLITE_OK);
265 int count = 0;
266 EXPECT_EQ(sqlite3_exec(db, "SELECT entryId, entryName FROM salary;", UtQueryResult, &count, nullptr), SQLITE_OK);
267 EXPECT_EQ(hitCksmFault_, 1);
268 EXPECT_EQ(count, TEST_PRESET_DATA_COUNT);
269 sqlite3_close_v2(db);
270 }
271
272 } // namespace Test
273