1 /*
2 * Copyright (c) 2022 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
16 #include <cstring>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19
20 #include "sqlite3_utils.h"
21 #include "softbus_adapter_file.h"
22 #include "softbus_adapter_mem.h"
23 #include "softbus_bus_center.h"
24 #include "softbus_errcode.h"
25
26 namespace OHOS {
27 using namespace testing::ext;
28
29 constexpr char DEVICE1_HASH[] = "6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b";
30 constexpr char DEVICE2_HASH[] = "d4735e3a265e16eee03f59718b9b5d03019c07d8b6c51f90da3a666eec13ab35";
31 constexpr char USER1_ID[] = "4e07408562bedb8b60ce05c1decfe3ad16b72230967de01f640b7e4729b49fce";
32 constexpr char USER2_ID[] = "4b227777d4dd1fc61c6f884f48641d02b4d121d3fd328cb08b5531fcacdabf8a";
33 constexpr uint8_t PASSWORD1[] = "ef2d127de37b942baad06145e54b0c619a1f22327b2ebbcfbec78f5564afe39d";
34 constexpr uint8_t PASSWORD2[] = "e7f6c011776e8db7cd330b54174fd76f7d0216b612387a5ffcfb81e6f0919683";
35
36 static TrustedDevInfoRecord g_record1, g_record2, g_record3;
37
38 class Sqlite3UtilsTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp();
43 void TearDown();
44 };
45
SetUpTestCase()46 void Sqlite3UtilsTest::SetUpTestCase()
47 {
48 (void)strcpy_s(g_record1.accountHexHash, SHA_256_HEX_HASH_LEN, USER1_ID);
49 (void)strcpy_s(g_record1.udid, UDID_BUF_LEN, DEVICE1_HASH);
50 (void)strcpy_s(g_record2.accountHexHash, SHA_256_HEX_HASH_LEN, USER1_ID);
51 (void)strcpy_s(g_record2.udid, UDID_BUF_LEN, DEVICE2_HASH);
52 (void)strcpy_s(g_record3.accountHexHash, SHA_256_HEX_HASH_LEN, USER2_ID);
53 (void)strcpy_s(g_record3.udid, UDID_BUF_LEN, DEVICE1_HASH);
54 }
55
TearDownTestCase()56 void Sqlite3UtilsTest::TearDownTestCase()
57 {
58 }
59
SetUp()60 void Sqlite3UtilsTest::SetUp()
61 {
62 }
63
TearDown()64 void Sqlite3UtilsTest::TearDown()
65 {
66 SoftBusRemoveFile(DATABASE_NAME);
67 }
68
69 /*
70 * @tc.name: Open_Database_Test_001
71 * @tc.desc: open database test
72 * @tc.type: FUNC
73 * @tc.require: I5PIFW
74 */
75 HWTEST_F(Sqlite3UtilsTest, Open_Database_Test_01, TestSize.Level0)
76 {
77 DbContext **ctxPtr = nullptr;
78
79 EXPECT_EQ(OpenDatabase(ctxPtr), SOFTBUS_INVALID_PARAM);
80 }
81
82 /*
83 * @tc.name: Open_Database_Test_002
84 * @tc.desc: open database test
85 * @tc.type: FUNC
86 * @tc.require: I5PIFW
87 */
88 HWTEST_F(Sqlite3UtilsTest, Open_Database_Test_02, TestSize.Level0)
89 {
90 DbContext *ctx = nullptr;
91
92 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
93 ASSERT_TRUE(ctx != nullptr);
94 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
95 }
96
97 /*
98 * @tc.name: Open_Database_Test_003
99 * @tc.desc: open database test
100 * @tc.type: FUNC
101 * @tc.require: I5PIFW
102 */
103 HWTEST_F(Sqlite3UtilsTest, Open_Database_Test_03, TestSize.Level0)
104 {
105 DbContext *ctx = nullptr;
106
107 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
108 ASSERT_TRUE(ctx != nullptr);
109 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
110 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
111 ASSERT_TRUE(ctx != nullptr);
112 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
113 }
114
115 /*
116 * @tc.name: Create_Table_Test_001
117 * @tc.desc: create table test
118 * @tc.type: FUNC
119 * @tc.require: I5PIFW
120 */
121 HWTEST_F(Sqlite3UtilsTest, Create_Table_Test_001, TestSize.Level0)
122 {
123 DbContext *ctx = nullptr;
124
125 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_INVALID_PARAM);
126 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_INVALID_PARAM);
127 }
128
129 /*
130 * @tc.name: Create_Table_Test_002
131 * @tc.desc: create table test
132 * @tc.type: FUNC
133 * @tc.require: I5PIFW
134 */
135 HWTEST_F(Sqlite3UtilsTest, Create_Table_Test_002, TestSize.Level0)
136 {
137 bool isExist = false;
138 DbContext *ctx = nullptr;
139
140 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
141 ASSERT_TRUE(ctx != nullptr);
142 EXPECT_EQ(CheckTableExist(ctx, TABLE_TRUSTED_DEV_INFO, &isExist), SOFTBUS_OK);
143 EXPECT_TRUE(!isExist);
144 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
145 EXPECT_EQ(CheckTableExist(ctx, TABLE_TRUSTED_DEV_INFO, &isExist), SOFTBUS_OK);
146 EXPECT_TRUE(isExist);
147 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
148 EXPECT_EQ(CheckTableExist(ctx, TABLE_TRUSTED_DEV_INFO, &isExist), SOFTBUS_OK);
149 EXPECT_TRUE(!isExist);
150 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
151 }
152
153 /*
154 * @tc.name: Create_and_Encrypt_Database_Test_001
155 * @tc.desc: create and encrypt database test
156 * @tc.type: FUNC
157 * @tc.require: I5PIFW
158 */
159 HWTEST_F(Sqlite3UtilsTest, Create_and_Encrypt_Database_Test_001, TestSize.Level0)
160 {
161 bool isExist = false;
162 DbContext *ctx = nullptr;
163
164 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
165 ASSERT_TRUE(ctx != nullptr);
166 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
167 EXPECT_EQ(CheckTableExist(ctx, TABLE_TRUSTED_DEV_INFO, &isExist), SOFTBUS_OK);
168 EXPECT_TRUE(!isExist);
169 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
170 EXPECT_EQ(CheckTableExist(ctx, TABLE_TRUSTED_DEV_INFO, &isExist), SOFTBUS_OK);
171 EXPECT_TRUE(isExist);
172 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
173 EXPECT_EQ(CheckTableExist(ctx, TABLE_TRUSTED_DEV_INFO, &isExist), SOFTBUS_OK);
174 EXPECT_TRUE(!isExist);
175 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
176 }
177
178 /*
179 * @tc.name: Create_and_Encrypt_Database_Test_002
180 * @tc.desc: create and encrypt database test
181 * @tc.type: FUNC
182 * @tc.require: I5PIFW
183 */
184 HWTEST_F(Sqlite3UtilsTest, Create_and_Encrypt_Database_Test_002, TestSize.Level0)
185 {
186 DbContext *ctx = nullptr;
187
188 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
189 ASSERT_TRUE(ctx != nullptr);
190 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
191 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
192 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
193 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
194
195 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
196 ASSERT_TRUE(ctx != nullptr);
197 EXPECT_NE(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
198 EXPECT_NE(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
199 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
200
201 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
202 ASSERT_TRUE(ctx != nullptr);
203 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
204 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
205 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
206 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
207
208 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
209 ASSERT_TRUE(ctx != nullptr);
210 EXPECT_NE(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
211 EXPECT_NE(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
212 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
213 }
214
215 /*
216 * @tc.name: Create_and_Encrypt_Database_Test_003
217 * @tc.desc: create and encrypt database test
218 * @tc.type: FUNC
219 * @tc.require: I5PIFW
220 */
221 HWTEST_F(Sqlite3UtilsTest, Create_and_Encrypt_Database_Test_003, TestSize.Level0)
222 {
223 DbContext *ctx = nullptr;
224
225 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
226 ASSERT_TRUE(ctx != nullptr);
227 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
228 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
229 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
230 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
231
232 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
233 ASSERT_TRUE(ctx != nullptr);
234 EXPECT_EQ(EncryptedDb(ctx, PASSWORD2, sizeof(PASSWORD2)), SOFTBUS_OK);
235 EXPECT_NE(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
236 EXPECT_NE(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
237 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
238
239 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
240 ASSERT_TRUE(ctx != nullptr);
241 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
242 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
243 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
244 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
245
246 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
247 ASSERT_TRUE(ctx != nullptr);
248 EXPECT_EQ(EncryptedDb(ctx, PASSWORD2, sizeof(PASSWORD2)), SOFTBUS_OK);
249 EXPECT_NE(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
250 EXPECT_NE(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
251 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
252 }
253
254 /*
255 * @tc.name: Create_and_Encrypt_Database_Test_004
256 * @tc.desc: create and encrypt database test
257 * @tc.type: FUNC
258 * @tc.require: I5PIFW
259 */
260 HWTEST_F(Sqlite3UtilsTest, Create_and_Encrypt_Database_Test_004, TestSize.Level0)
261 {
262 DbContext *ctx = nullptr;
263
264 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
265 ASSERT_TRUE(ctx != nullptr);
266 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
267 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
268 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
269 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
270
271 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
272 ASSERT_TRUE(ctx != nullptr);
273 EXPECT_EQ(UpdateDbPassword(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
274 EXPECT_NE(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
275 EXPECT_NE(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
276 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
277
278 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
279 ASSERT_TRUE(ctx != nullptr);
280 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
281 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
282 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
283 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
284
285 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
286 ASSERT_TRUE(ctx != nullptr);
287 EXPECT_EQ(UpdateDbPassword(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
288 EXPECT_NE(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
289 EXPECT_NE(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
290 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
291 }
292
293 /*
294 * @tc.name: Create_and_Encrypt_Database_Test_005
295 * @tc.desc: create and encrypt database test
296 * @tc.type: FUNC
297 * @tc.require: I5PIFW
298 */
299 HWTEST_F(Sqlite3UtilsTest, Create_and_Encrypt_Database_Test_005, TestSize.Level0)
300 {
301 DbContext *ctx = nullptr;
302
303 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
304 ASSERT_TRUE(ctx != nullptr);
305 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
306 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
307 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
308 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
309
310 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
311 ASSERT_TRUE(ctx != nullptr);
312 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
313 EXPECT_EQ(UpdateDbPassword(ctx, PASSWORD2, sizeof(PASSWORD2)), SOFTBUS_OK);
314 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
315 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
316 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
317
318 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
319 ASSERT_TRUE(ctx != nullptr);
320 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
321 EXPECT_NE(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
322 EXPECT_NE(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
323 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
324
325 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
326 ASSERT_TRUE(ctx != nullptr);
327 EXPECT_EQ(EncryptedDb(ctx, PASSWORD2, sizeof(PASSWORD2)), SOFTBUS_OK);
328 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
329 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
330 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
331 }
332
333 /*
334 * @tc.name: Insert_data_Inerface_Test_001
335 * @tc.desc: insert data interface test
336 * @tc.type: FUNC
337 * @tc.require: I5PIFW
338 */
339 HWTEST_F(Sqlite3UtilsTest, Insert_data_Inerface_Test_001, TestSize.Level0)
340 {
341 DbContext *ctx = nullptr;
342
343 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
344 ASSERT_TRUE(ctx != nullptr);
345 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
346 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 0);
347 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
348 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 0);
349 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
350 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 1);
351 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
352 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 0);
353 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
354 }
355
356 /*
357 * @tc.name: Insert_data_Inerface_Test_002
358 * @tc.desc: insert data interface test
359 * @tc.type: FUNC
360 * @tc.require: I5PIFW
361 */
362 HWTEST_F(Sqlite3UtilsTest, Insert_data_Inerface_Test_002, TestSize.Level0)
363 {
364 DbContext *ctx = nullptr;
365
366 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
367 ASSERT_TRUE(ctx != nullptr);
368 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
369 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
370 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
371 EXPECT_NE(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
372 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 1);
373 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record2), SOFTBUS_OK);
374 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 2);
375 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record3), SOFTBUS_OK);
376 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER2_ID), 1);
377 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
378 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
379 }
380
381 /*
382 * @tc.name: Remove_data_Inerface_Test_001
383 * @tc.desc: remove data interface test
384 * @tc.type: FUNC
385 * @tc.require: I5PIFW
386 */
387 HWTEST_F(Sqlite3UtilsTest, Remove_data_Inerface_Test_001, TestSize.Level0)
388 {
389 DbContext *ctx = nullptr;
390
391 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
392 ASSERT_TRUE(ctx != nullptr);
393 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
394 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
395 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
396 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 1);
397 EXPECT_EQ(RemoveAllRecord(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
398 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 0);
399 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
400 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 1);
401 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
402 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
403 }
404
405 /*
406 * @tc.name: Remove_data_Inerface_Test_002
407 * @tc.desc: remove data interface test
408 * @tc.type: FUNC
409 * @tc.require: I5PIFW
410 */
411 HWTEST_F(Sqlite3UtilsTest, Remove_data_Inerface_Test_002, TestSize.Level0)
412 {
413 DbContext *ctx = nullptr;
414
415 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
416 ASSERT_TRUE(ctx != nullptr);
417 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
418 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
419 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
420 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 1);
421 EXPECT_EQ(RemoveRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
422 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 0);
423 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
424 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 1);
425 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
426 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
427 }
428
429 /*
430 * @tc.name: Remove_data_Inerface_Test_003
431 * @tc.desc: remove data interface test
432 * @tc.type: FUNC
433 * @tc.require: I5PIFW
434 */
435 HWTEST_F(Sqlite3UtilsTest, Remove_data_Inerface_Test_003, TestSize.Level0)
436 {
437 DbContext *ctx = nullptr;
438
439 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
440 ASSERT_TRUE(ctx != nullptr);
441 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
442 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
443 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
444 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 1);
445 EXPECT_EQ(RemoveRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record2), SOFTBUS_OK);
446 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 1);
447 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record2), SOFTBUS_OK);
448 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 2);
449 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
450 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
451 }
452
453 /*
454 * @tc.name: Query_data_Inerface_Test_001
455 * @tc.desc: query data interface test
456 * @tc.type: FUNC
457 * @tc.require: I5PIFW
458 */
459 HWTEST_F(Sqlite3UtilsTest, Query_data_Inerface_Test_001, TestSize.Level0)
460 {
461 int32_t num;
462 DbContext *ctx = nullptr;
463 char *record;
464
465 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
466 ASSERT_TRUE(ctx != nullptr);
467 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
468 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
469 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
470 num = GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID);
471 ASSERT_TRUE(num != 0);
472 record = (char *)SoftBusCalloc(num * UDID_BUF_LEN);
473 ASSERT_TRUE(record != nullptr);
474 EXPECT_EQ(QueryRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID,
475 (uint8_t **)&record, num), SOFTBUS_OK);
476 EXPECT_STREQ(record, DEVICE1_HASH);
477 SoftBusFree(record);
478 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
479 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
480 }
481
482 /*
483 * @tc.name: Query_data_Inerface_Test_002
484 * @tc.desc: query data interface test
485 * @tc.type: FUNC
486 * @tc.require: I5PIFW
487 */
488 HWTEST_F(Sqlite3UtilsTest, Query_data_Inerface_Test_002, TestSize.Level0)
489 {
490 int32_t num;
491 DbContext *ctx = nullptr;
492 char *record;
493
494 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
495 ASSERT_TRUE(ctx != nullptr);
496 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
497 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
498 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
499 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record2), SOFTBUS_OK);
500 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record3), SOFTBUS_OK);
501 num = GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID);
502 ASSERT_TRUE(num != 0);
503 record = (char *)SoftBusCalloc(num * UDID_BUF_LEN);
504 ASSERT_TRUE(record != nullptr);
505 EXPECT_EQ(QueryRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID,
506 (uint8_t **)&record, num), SOFTBUS_OK);
507 EXPECT_STREQ(record, DEVICE1_HASH);
508 EXPECT_STREQ(record + UDID_BUF_LEN, DEVICE2_HASH);
509 SoftBusFree(record);
510 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
511 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
512 }
513
514 /*
515 * @tc.name: Open_and_Close_Transaction_Test_001
516 * @tc.desc: open and close transaction test
517 * @tc.type: FUNC
518 * @tc.require: I5PIFW
519 */
520 HWTEST_F(Sqlite3UtilsTest, Open_and_Close_Transaction_Test_001, TestSize.Level0)
521 {
522 DbContext *ctx = nullptr;
523
524 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
525 ASSERT_TRUE(ctx != nullptr);
526 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
527 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
528 EXPECT_EQ(OpenTransaction(ctx), SOFTBUS_OK);
529 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
530 EXPECT_EQ(CloseTransaction(ctx, CLOSE_TRANS_ROLLBACK), SOFTBUS_OK);
531 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), 0);
532 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
533 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
534 }
535
536 /*
537 * @tc.name: Open_and_Close_Transaction_Test_002
538 * @tc.desc: open and close transaction test
539 * @tc.type: FUNC
540 * @tc.require: I5PIFW
541 */
542 HWTEST_F(Sqlite3UtilsTest, Open_and_Close_Transaction_Test_002, TestSize.Level0)
543 {
544 int32_t num;
545 DbContext *ctx = nullptr;
546 char *record;
547
548 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
549 ASSERT_TRUE(ctx != nullptr);
550 EXPECT_EQ(EncryptedDb(ctx, PASSWORD1, sizeof(PASSWORD1)), SOFTBUS_OK);
551 EXPECT_EQ(CreateTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
552 EXPECT_EQ(OpenTransaction(ctx), SOFTBUS_OK);
553 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&g_record1), SOFTBUS_OK);
554 EXPECT_EQ(CloseTransaction(ctx, CLOSE_TRANS_COMMIT), SOFTBUS_OK);
555 num = GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID);
556 ASSERT_TRUE(num != 0);
557 record = (char *)SoftBusCalloc(num * UDID_BUF_LEN);
558 ASSERT_TRUE(record != nullptr);
559 EXPECT_EQ(QueryRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID,
560 (uint8_t **)&record, num), SOFTBUS_OK);
561 EXPECT_STREQ(record, DEVICE1_HASH);
562 SoftBusFree(record);
563 EXPECT_EQ(DeleteTable(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_OK);
564 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
565 }
566
567 /*
568 * @tc.name: Open_Database_Test_001
569 * @tc.desc: open database test
570 * @tc.type: FUNC
571 * @tc.require:
572 */
573 HWTEST_F(Sqlite3UtilsTest, Open_Database_Test_001, TestSize.Level0)
574 {
575 DbContext *ctxPtr = nullptr;
576 bool *isExist = nullptr;
577
578 EXPECT_EQ(CheckTableExist(ctxPtr, TABLE_TRUSTED_DEV_INFO, isExist), SOFTBUS_INVALID_PARAM);
579 EXPECT_EQ(OpenDatabase(&ctxPtr), SOFTBUS_OK);
580 isExist = nullptr;
581 int testid = CheckTableExist(ctxPtr, TABLE_TRUSTED_DEV_INFO, isExist);
582 EXPECT_EQ(testid, SOFTBUS_INVALID_PARAM);
583 }
584
585 /*
586 * @tc.name: Insert_Record_Test_001
587 * @tc.desc: insert record test
588 * @tc.type: FUNC
589 * @tc.require:
590 */
591 HWTEST_F(Sqlite3UtilsTest, Insert_Record_Test_001, TestSize.Level0)
592 {
593 DbContext *ctx = nullptr;
594 uint8_t *g_record = NULL;
595 EXPECT_EQ(InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, g_record), SOFTBUS_INVALID_PARAM);
596 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
597 int testid = InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, g_record);
598 EXPECT_EQ(testid, SOFTBUS_INVALID_PARAM);
599 }
600
601 /*
602 * @tc.name: Close_Database_Test_001
603 * @tc.desc: close database test
604 * @tc.type: FUNC
605 * @tc.require:
606 */
607 HWTEST_F(Sqlite3UtilsTest, Close_Database_Test_001, TestSize.Level0)
608 {
609 DbContext *ctx = nullptr;
610
611 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_INVALID_PARAM);
612 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
613 EXPECT_EQ(CloseDatabase(ctx), SOFTBUS_OK);
614 }
615
616 /*
617 * @tc.name: Db_Password_Test_001
618 * @tc.desc: db password test
619 * @tc.type: FUNC
620 * @tc.require:
621 */
622 HWTEST_F(Sqlite3UtilsTest, Db_Password_Test_001, TestSize.Level0)
623 {
624 DbContext *ctx = nullptr;
625 uint8_t *password = nullptr;
626 uint32_t len = 0;
627
628 EXPECT_EQ(EncryptedDb(ctx, password, len), SOFTBUS_INVALID_PARAM);
629 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
630 ASSERT_TRUE(ctx != nullptr);
631 EXPECT_EQ(EncryptedDb(ctx, password, len), SOFTBUS_INVALID_PARAM);
632 int testid = EncryptedDb(ctx, PASSWORD1, len);
633 EXPECT_EQ(testid, SOFTBUS_ERR);
634
635 ctx = nullptr;
636 EXPECT_EQ(UpdateDbPassword(ctx, password, len), SOFTBUS_INVALID_PARAM);
637 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
638 ASSERT_TRUE(ctx != nullptr);
639 EXPECT_EQ(UpdateDbPassword(ctx, password, len), SOFTBUS_INVALID_PARAM);
640 testid = UpdateDbPassword(ctx, PASSWORD1, len);
641 EXPECT_EQ(testid, SOFTBUS_ERR);
642 }
643
644 /*
645 * @tc.name: Remove_Record_Key_001
646 * @tc.desc: remove record key
647 * @tc.type: FUNC
648 * @tc.require:
649 */
650 HWTEST_F(Sqlite3UtilsTest, Remove_Record_Key_001, TestSize.Level0)
651 {
652 DbContext *ctx = nullptr;
653 char *record = (char *)SoftBusCalloc(0 * UDID_BUF_LEN);
654 uint8_t *g_record = NULL;
655
656 EXPECT_EQ(RemoveRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, g_record), SOFTBUS_INVALID_PARAM);
657 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
658 EXPECT_EQ(RemoveRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, g_record), SOFTBUS_INVALID_PARAM);
659 ctx = nullptr;
660 EXPECT_EQ(RemoveAllRecord(ctx, TABLE_TRUSTED_DEV_INFO), SOFTBUS_INVALID_PARAM);
661 EXPECT_EQ(GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID), SOFTBUS_OK);
662 EXPECT_EQ(QueryRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)USER1_ID,
663 (uint8_t **)&record, 0), SOFTBUS_INVALID_PARAM);
664 EXPECT_EQ(OpenTransaction(ctx), SOFTBUS_INVALID_PARAM);
665 EXPECT_EQ(CloseTransaction(ctx, CLOSE_TRANS_COMMIT), SOFTBUS_INVALID_PARAM);
666 }
667
668 /*
669 * @tc.name: Get_Query_Result_001
670 * @tc.desc: Get Record Key test
671 * @tc.type: FUNC
672 * @tc.require:
673 */
674 HWTEST_F(Sqlite3UtilsTest, Get_Query_Result_001, TestSize.Level0)
675 {
676 DbContext *ctx = nullptr;
677 int32_t icol = -1;
678 char *text = nullptr;
679 int32_t value32 = 1;
680 int64_t value64 = 1;
681 double valuedouble = 1;
682
683 EXPECT_EQ(GetQueryResultColText(ctx, icol, text, UDID_BUF_LEN), SOFTBUS_INVALID_PARAM);
684 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
685 EXPECT_EQ(GetQueryResultColText(ctx, icol, text, UDID_BUF_LEN), SOFTBUS_INVALID_PARAM);
686 icol = 1;
687 EXPECT_EQ(GetQueryResultColText(ctx, icol, text, UDID_BUF_LEN), SOFTBUS_INVALID_PARAM);
688
689 ctx = nullptr;
690 icol = -1;
691 EXPECT_EQ(GetQueryResultColInt(ctx, icol, &value32), SOFTBUS_INVALID_PARAM);
692 EXPECT_EQ(GetQueryResultColInt64(ctx, icol, &value64), SOFTBUS_INVALID_PARAM);
693 EXPECT_EQ(GetQueryResultColDouble(ctx, icol, &valuedouble), SOFTBUS_INVALID_PARAM);
694 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
695 EXPECT_EQ(GetQueryResultColInt(ctx, icol, &value32), SOFTBUS_INVALID_PARAM);
696 EXPECT_EQ(GetQueryResultColInt64(ctx, icol, &value64), SOFTBUS_INVALID_PARAM);
697 EXPECT_EQ(GetQueryResultColDouble(ctx, icol, &valuedouble), SOFTBUS_INVALID_PARAM);
698 EXPECT_EQ(GetQueryResultColCount(ctx, &value32), SOFTBUS_INVALID_PARAM);
699 }
700
701 /*
702 * @tc.name: Bind_Para_Test_001
703 * @tc.desc: bind para test
704 * @tc.type: FUNC
705 * @tc.require:
706 */
707 HWTEST_F(Sqlite3UtilsTest, Bind_Para_Test_001, TestSize.Level0)
708 {
709 DbContext *ctx = nullptr;
710 DbContext *ctx_1 = nullptr;
711 int32_t idx = -1;
712 int32_t value32 = 1;
713 int32_t value64 = 1;
714 double valuedouble = 0.0;
715 char *valuetext = nullptr;
716 char ch[] = "abcdefghijklmn";
717 char *valuetext1 = ch;
718 int32_t result = 0;
719
720 EXPECT_EQ(BindParaInt(ctx, idx, value32), SQLITE_ERROR);
721 EXPECT_EQ(BindParaInt64(ctx, idx, value64), SQLITE_ERROR);
722 EXPECT_EQ(BindParaDouble(ctx, idx, valuedouble), SQLITE_ERROR);
723 EXPECT_EQ(OpenDatabase(&ctx), SOFTBUS_OK);
724 EXPECT_EQ(BindParaInt(ctx, idx, value32), SQLITE_ERROR);
725 EXPECT_EQ(BindParaInt64(ctx, idx, value64), SQLITE_ERROR);
726 EXPECT_EQ(BindParaDouble(ctx, idx, valuedouble), SQLITE_ERROR);
727 idx = 1;
728 result = BindParaInt(ctx, idx, value32);
729 EXPECT_EQ(result, 1);
730 result = BindParaInt64(ctx, idx, value64);
731 EXPECT_EQ(result, 1);
732 result = BindParaDouble(ctx, idx, valuedouble);
733 EXPECT_EQ(result, 1);
734
735 ctx_1 = nullptr;
736 EXPECT_EQ(BindParaText(ctx_1, idx, valuetext, 0), SQLITE_ERROR);
737 EXPECT_EQ(OpenDatabase(&ctx_1), SOFTBUS_OK);
738 idx = -1;
739 EXPECT_EQ(BindParaText(ctx_1, idx, valuetext, 0), SQLITE_ERROR);
740 idx = 1;
741 EXPECT_EQ(BindParaText(ctx_1, idx, valuetext, 0), SQLITE_ERROR);
742 valuetext1[0] = '\0';
743 EXPECT_EQ(BindParaText(ctx_1, idx, valuetext1, strlen(valuetext1)), SQLITE_ERROR);
744 valuetext1[0] = '1';
745 EXPECT_EQ(BindParaText(ctx_1, idx, valuetext1, strlen(valuetext1)), SQLITE_ERROR);
746 }
747 } // namespace OHOS
748