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