1 /*
2 * Copyright (c) 2021 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 <gtest/gtest.h>
17
18 #include <string>
19
20 #include "common.h"
21 #include "logger.h"
22 #include "rdb_errno.h"
23 #include "rdb_helper.h"
24 #include "rdb_open_callback.h"
25 #include "unistd.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::Rdb;
29 using namespace OHOS::NativeRdb;
30
31 class RdbStoreConfigTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
39 class ConfigTestOpenCallback : public RdbOpenCallback {
40 public:
41 int OnCreate(RdbStore &store) override;
42 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
43 static const std::string CREATE_TABLE_TEST;
44 };
45
46 const std::string ConfigTestOpenCallback::CREATE_TABLE_TEST =
47 std::string("CREATE TABLE IF NOT EXISTS test ") + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
48 "name TEXT NOT NULL, age INTEGER, salary "
49 "REAL, blobType BLOB)");
50
OnCreate(RdbStore & store)51 int ConfigTestOpenCallback::OnCreate(RdbStore &store)
52 {
53 return store.ExecuteSql(CREATE_TABLE_TEST);
54 }
55
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)56 int ConfigTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
57 {
58 return E_OK;
59 }
60
61 class ConfigTestVisitorOpenCallback : public RdbOpenCallback {
62 public:
63 int OnCreate(RdbStore &store) override;
64 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
65 static const std::string CREATE_TABLE_TEST;
66 };
67
OnCreate(RdbStore & store)68 int ConfigTestVisitorOpenCallback::OnCreate(RdbStore &store)
69 {
70 return E_OK;
71 }
72
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)73 int ConfigTestVisitorOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
74 {
75 return E_OK;
76 }
77
SetUpTestCase(void)78 void RdbStoreConfigTest::SetUpTestCase(void)
79 {
80 RdbHelper::ClearCache();
81 RdbHelper::DeleteRdbStore(RDB_TEST_PATH + "config_test.db");
82 }
83
TearDownTestCase(void)84 void RdbStoreConfigTest::TearDownTestCase(void)
85 {
86 RdbHelper::ClearCache();
87 RdbHelper::DeleteRdbStore(RDB_TEST_PATH + "config_test.db");
88 }
89
SetUp(void)90 void RdbStoreConfigTest::SetUp(void)
91 {
92 RdbHelper::ClearCache();
93 RdbHelper::DeleteRdbStore(RDB_TEST_PATH + "config_test.db");
94 }
95
TearDown(void)96 void RdbStoreConfigTest::TearDown(void)
97 {
98 RdbHelper::ClearCache();
99 RdbHelper::DeleteRdbStore(RDB_TEST_PATH + "config_test.db");
100 }
101
102 /**
103 * @tc.name: RdbStoreConfig_001
104 * @tc.desc: test RdbStoreConfig
105 * @tc.type: FUNC
106 */
107 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_001, TestSize.Level1)
108 {
109 int errCode = E_OK;
110 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
111 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
112 ConfigTestOpenCallback helper;
113 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
114 EXPECT_NE(store, nullptr);
115 EXPECT_EQ(errCode, E_OK);
116
117 int64_t id;
118 ValuesBucket values;
119 values.PutInt("id", 1);
120 values.PutString("name", std::string("zhangsan"));
121 values.PutInt("age", 18);
122 values.PutDouble("salary", 100.5);
123 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
124 int ret = store->Insert(id, "test", values);
125 EXPECT_EQ(ret, E_OK);
126 EXPECT_EQ(1, id);
127
128 ret = access(dbPath.c_str(), F_OK);
129 EXPECT_EQ(ret, 0);
130
131 int currentVersion;
132 ret = store->GetVersion(currentVersion);
133 EXPECT_EQ(ret, E_OK);
134 EXPECT_EQ(1, currentVersion);
135
136 store = nullptr;
137 RdbHelper::ClearCache();
138 ret = RdbHelper::DeleteRdbStore(dbPath);
139 EXPECT_EQ(ret, E_OK);
140
141 StorageMode mode = config.GetStorageMode();
142 StorageMode targeMode = StorageMode::MODE_DISK;
143 EXPECT_EQ(mode, targeMode);
144 store = nullptr;
145 }
146
147 /**
148 * @tc.name: RdbStoreConfig_002
149 * @tc.desc: test RdbStoreConfig
150 * @tc.type: FUNC
151 */
152 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_002, TestSize.Level1)
153 {
154 int errCode = E_OK;
155 RdbStoreConfig config("", StorageMode::MODE_MEMORY);
156 ConfigTestOpenCallback helper;
157 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
158 EXPECT_NE(store, nullptr);
159 EXPECT_EQ(errCode, E_OK);
160
161 int64_t id;
162 ValuesBucket values;
163 values.PutInt("id", 1);
164 values.PutString("name", std::string("zhangsan"));
165 values.PutInt("age", 18);
166 values.PutDouble("salary", 100.5);
167 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
168 int ret = store->Insert(id, "test", values);
169 EXPECT_EQ(ret, E_OK);
170 EXPECT_EQ(1, id);
171
172 int currentVersion;
173 ret = store->GetVersion(currentVersion);
174 EXPECT_EQ(ret, E_OK);
175 EXPECT_EQ(1, currentVersion);
176
177 store->SetVersion(5);
178 ret = store->GetVersion(currentVersion);
179 EXPECT_EQ(ret, E_OK);
180 EXPECT_EQ(5, currentVersion);
181
182 store->SetVersion(2147483647);
183 ret = store->GetVersion(currentVersion);
184 EXPECT_EQ(ret, E_OK);
185 EXPECT_EQ(2147483647, currentVersion);
186
187 store->SetVersion(-2147483648);
188 ret = store->GetVersion(currentVersion);
189 EXPECT_EQ(ret, E_OK);
190 EXPECT_EQ(-2147483648, currentVersion);
191
192 std::string journalMode;
193 ret = store->ExecuteAndGetString(journalMode, "PRAGMA journal_mode");
194 EXPECT_EQ(ret, E_OK);
195 EXPECT_EQ(journalMode, "memory");
196
197 StorageMode mode = config.GetStorageMode();
198 StorageMode targeMode = StorageMode::MODE_MEMORY;
199 EXPECT_EQ(mode, targeMode);
200 store = nullptr;
201 }
202
203 /**
204 * @tc.name: RdbStoreConfig_003
205 * @tc.desc: test RdbStoreConfig
206 * @tc.type: FUNC
207 */
208 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_003, TestSize.Level1)
209 {
210 int errCode = E_OK;
211 RdbStoreConfig config("", StorageMode::MODE_DISK, false);
212 ConfigTestOpenCallback helper;
213 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
214 EXPECT_EQ(store, nullptr);
215 EXPECT_EQ(errCode, E_INVALID_FILE_PATH);
216 }
217
218 /**
219 * @tc.name: RdbStoreConfig_004
220 * @tc.desc: test RdbStoreConfig
221 * @tc.type: FUNC
222 */
223 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_004, TestSize.Level1)
224 {
225 int errCode = E_OK;
226 const std::string dbPath = "config_test.db";
227 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
228 ConfigTestOpenCallback helper;
229 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
230 EXPECT_EQ(store, nullptr);
231 EXPECT_EQ(errCode, E_INVALID_FILE_PATH);
232 }
233
234 /**
235 * @tc.name: RdbStoreConfig_005
236 * @tc.desc: test RdbStoreConfig journalMode
237 * @tc.type: FUNC
238 */
239 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_005, TestSize.Level1)
240 {
241 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
242 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
243 std::string journalMode = config.GetJournalMode();
244 EXPECT_EQ(journalMode, "WAL");
245 ConfigTestOpenCallback helper;
246 int errCode = E_OK;
247 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
248 EXPECT_NE(store, nullptr);
249
250 std::string currentMode;
251 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
252 EXPECT_EQ(ret, E_OK);
253 EXPECT_EQ(currentMode, "wal");
254 store = nullptr;
255 }
256
257 /**
258 * @tc.name: RdbStoreConfig_006
259 * @tc.desc: test RdbStoreConfig journalMode
260 * @tc.type: FUNC
261 */
262 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_006, TestSize.Level1)
263 {
264 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
265 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
266 config.SetJournalMode(JournalMode::MODE_DELETE);
267 std::string journalMode = config.GetJournalMode();
268 EXPECT_EQ(journalMode, "DELETE");
269 ConfigTestOpenCallback helper;
270 int errCode = E_OK;
271 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
272 EXPECT_NE(store, nullptr);
273
274 std::string currentMode;
275 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
276 EXPECT_EQ(ret, E_OK);
277 EXPECT_EQ(currentMode, "delete");
278 store = nullptr;
279 }
280
281 /**
282 * @tc.name: RdbStoreConfig_007
283 * @tc.desc: test RdbStoreConfig journalMode
284 * @tc.type: FUNC
285 */
286 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_007, TestSize.Level1)
287 {
288 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
289 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
290 config.SetJournalMode(JournalMode::MODE_TRUNCATE);
291 std::string journalMode = config.GetJournalMode();
292 EXPECT_EQ(journalMode, "TRUNCATE");
293 ConfigTestOpenCallback helper;
294 int errCode = E_OK;
295 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
296 EXPECT_NE(store, nullptr);
297
298 std::string currentMode;
299 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
300 EXPECT_EQ(ret, E_OK);
301 EXPECT_EQ(currentMode, "truncate");
302 store = nullptr;
303 }
304
305 /**
306 * @tc.name: RdbStoreConfig_008
307 * @tc.desc: test RdbStoreConfig journalMode
308 * @tc.type: FUNC
309 */
310 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_008, TestSize.Level1)
311 {
312 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
313 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
314 config.SetJournalMode(JournalMode::MODE_PERSIST);
315 std::string journalMode = config.GetJournalMode();
316 EXPECT_EQ(journalMode, "PERSIST");
317 ConfigTestOpenCallback helper;
318 int errCode = E_OK;
319 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
320 EXPECT_NE(store, nullptr);
321
322 std::string currentMode;
323 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
324 EXPECT_EQ(ret, E_OK);
325 EXPECT_EQ(currentMode, "persist");
326 store = nullptr;
327 }
328
329 /**
330 * @tc.name: RdbStoreConfig_009
331 * @tc.desc: test RdbStoreConfig journalMode
332 * @tc.type: FUNC
333 */
334 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_009, TestSize.Level1)
335 {
336 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
337 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
338 config.SetJournalMode(JournalMode::MODE_MEMORY);
339 std::string journalMode = config.GetJournalMode();
340 EXPECT_EQ(journalMode, "MEMORY");
341 ConfigTestOpenCallback helper;
342 int errCode = E_OK;
343 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
344 EXPECT_NE(store, nullptr);
345
346 std::string currentMode;
347 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
348 EXPECT_EQ(ret, E_OK);
349 EXPECT_EQ(currentMode, "memory");
350 store = nullptr;
351 }
352 /**
353 * @tc.name: RdbStoreConfig_010
354 * @tc.desc: test RdbStoreConfig journalMode
355 * @tc.type: FUNC
356 */
357 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_010, TestSize.Level1)
358 {
359 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
360 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
361 config.SetJournalMode(JournalMode::MODE_WAL);
362 std::string journalMode = config.GetJournalMode();
363 EXPECT_EQ(journalMode, "WAL");
364 ConfigTestOpenCallback helper;
365 int errCode = E_OK;
366 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
367 EXPECT_NE(store, nullptr);
368
369 std::string currentMode;
370 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
371 EXPECT_EQ(ret, E_OK);
372 EXPECT_EQ(currentMode, "wal");
373 store = nullptr;
374 }
375
376 /**
377 * @tc.name: RdbStoreConfig_011
378 * @tc.desc: test RdbStoreConfig journalMode
379 * @tc.type: FUNC
380 */
381 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_011, TestSize.Level1)
382 {
383 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
384 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
385 config.SetJournalMode(JournalMode::MODE_OFF);
386 std::string journalMode = config.GetJournalMode();
387 EXPECT_EQ(journalMode, "OFF");
388 ConfigTestOpenCallback helper;
389 int errCode = E_OK;
390 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
391 EXPECT_NE(store, nullptr);
392
393 std::string currentMode;
394 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
395 EXPECT_EQ(ret, E_OK);
396 EXPECT_EQ(currentMode, "off");
397 }
398
399 /**
400 * @tc.name: RdbStoreConfig_012
401 * @tc.desc: test RdbStoreConfig interfaces: SetSecurityLevel/GetSecurityLevel
402 * @tc.type: FUNC
403 */
404 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_012, TestSize.Level1)
405 {
406 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
407 RdbStoreConfig config(dbPath);
408
409 config.SetSecurityLevel(SecurityLevel::S2);
410 SecurityLevel retSecurityLevel = config.GetSecurityLevel();
411 EXPECT_EQ(SecurityLevel::S2, retSecurityLevel);
412
413 ConfigTestOpenCallback helper;
414 int errCode = E_ERROR;
415 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
416 EXPECT_NE(store, nullptr);
417 store = nullptr;
418 auto ret = RdbHelper::DeleteRdbStore(dbPath);
419 EXPECT_EQ(ret, E_OK);
420
421 config.SetSecurityLevel(SecurityLevel::LAST);
422 retSecurityLevel = config.GetSecurityLevel();
423 EXPECT_EQ(SecurityLevel::LAST, retSecurityLevel);
424 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
425 EXPECT_NE(store, nullptr);
426 }
427
428 /**
429 * @tc.name: RdbStoreConfig_013
430 * @tc.desc: test RdbStoreConfig interfaces: SetCreateNecessary/IsCreateNecessary
431 * @tc.type: FUNC
432 */
433 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_013, TestSize.Level1)
434 {
435 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
436 RdbStoreConfig config(dbPath);
437
438 bool createNecessary = true;
439 config.SetCreateNecessary(createNecessary);
440 bool retCreateNecessary = config.IsCreateNecessary();
441 EXPECT_EQ(createNecessary, retCreateNecessary);
442
443 ConfigTestOpenCallback helper;
444 int errCode = E_ERROR;
445 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
446 EXPECT_NE(store, nullptr);
447 store = nullptr;
448 auto ret = RdbHelper::DeleteRdbStore(dbPath);
449 EXPECT_EQ(ret, E_OK);
450
451 createNecessary = false;
452 config.SetCreateNecessary(createNecessary);
453 retCreateNecessary = config.IsCreateNecessary();
454 EXPECT_EQ(createNecessary, retCreateNecessary);
455
456 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
457 EXPECT_EQ(store, nullptr);
458 }
459
460 /**
461 * @tc.name: RdbStoreConfig_014
462 * @tc.desc: test RdbStoreConfig interfaces: SetReadOnly/IsReadOnly
463 * @tc.type: FUNC
464 */
465 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_014, TestSize.Level1)
466 {
467 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
468 RdbStoreConfig config(dbPath);
469
470 bool readOnly = true;
471 config.SetReadOnly(readOnly);
472 bool retReadOnly = config.IsReadOnly();
473 EXPECT_EQ(readOnly, retReadOnly);
474
475 ConfigTestOpenCallback helper;
476 int errCode = E_ERROR;
477 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
478 EXPECT_EQ(store, nullptr);
479 store = nullptr;
480 RdbHelper::DeleteRdbStore(dbPath);
481
482 readOnly = false;
483 config.SetReadOnly(readOnly);
484 retReadOnly = config.IsReadOnly();
485 EXPECT_EQ(readOnly, retReadOnly);
486
487 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
488 EXPECT_NE(store, nullptr);
489 // open the read only db failed, when the file is not exists;
490 store = nullptr;
491 readOnly = true;
492 config.SetReadOnly(readOnly);
493 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
494 EXPECT_NE(store, nullptr);
495
496 // open the read only db success, when the file is exists;
497 store = nullptr;
498 auto ret = RdbHelper::DeleteRdbStore(dbPath);
499 EXPECT_EQ(ret, E_OK);
500 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
501 EXPECT_EQ(store, nullptr);
502 }
503
504 /**
505 * @tc.name: RdbStoreConfig_015
506 * @tc.desc: test RdbStoreConfig interfaces: SetStorageMode/GetStorageMode
507 * @tc.type: FUNC
508 */
509 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_015, TestSize.Level1)
510 {
511 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
512 RdbStoreConfig config(dbPath);
513
514 StorageMode storageMode = StorageMode::MODE_DISK;
515 config.SetStorageMode(storageMode);
516 StorageMode retStorageMode = config.GetStorageMode();
517 EXPECT_EQ(storageMode, retStorageMode);
518
519 ConfigTestOpenCallback helper;
520 int errCode = E_ERROR;
521 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
522 EXPECT_NE(store, nullptr);
523 store = nullptr;
524 auto ret = RdbHelper::DeleteRdbStore(dbPath);
525 EXPECT_EQ(ret, E_OK);
526
527 storageMode = StorageMode::MODE_MEMORY;
528 config.SetStorageMode(storageMode);
529 retStorageMode = config.GetStorageMode();
530 EXPECT_EQ(storageMode, retStorageMode);
531
532 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
533 EXPECT_NE(store, nullptr);
534 }
535
536 /**
537 * @tc.name: RdbStoreConfig_016
538 * @tc.desc: test RdbStoreConfig interfaces: SetDatabaseFileType/GetDatabaseFileType
539 * @tc.type: FUNC
540 */
541 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_016, TestSize.Level1)
542 {
543 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
544 RdbStoreConfig config(dbPath);
545
546 DatabaseFileType databaseFileType = DatabaseFileType::NORMAL;
547 config.SetDatabaseFileType(databaseFileType);
548 std::string retDatabaseFileType = config.GetDatabaseFileType();
549 EXPECT_EQ("db", retDatabaseFileType);
550
551 ConfigTestOpenCallback helper;
552 int errCode = E_ERROR;
553 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
554 EXPECT_NE(store, nullptr);
555 store = nullptr;
556 auto ret = RdbHelper::DeleteRdbStore(dbPath);
557 EXPECT_EQ(ret, E_OK);
558
559 databaseFileType = DatabaseFileType::BACKUP;
560 config.SetDatabaseFileType(databaseFileType);
561 retDatabaseFileType = config.GetDatabaseFileType();
562 EXPECT_EQ("backup", retDatabaseFileType);
563
564 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
565 EXPECT_NE(store, nullptr);
566 store = nullptr;
567 ret = RdbHelper::DeleteRdbStore(dbPath);
568 EXPECT_EQ(ret, E_OK);
569
570 databaseFileType = DatabaseFileType::CORRUPT;
571 config.SetDatabaseFileType(databaseFileType);
572 retDatabaseFileType = config.GetDatabaseFileType();
573 EXPECT_EQ("corrupt", retDatabaseFileType);
574
575 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
576 EXPECT_NE(store, nullptr);
577 }
578
579 /**
580 * @tc.name: RdbStoreConfig_017
581 * @tc.desc: test RdbStoreConfig interfaces: SetDistributedType/GetDistributedType
582 * @tc.type: FUNC
583 */
584 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_017, TestSize.Level1)
585 {
586 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
587 RdbStoreConfig config(dbPath);
588
589 DistributedType distributedType = DistributedType::RDB_DEVICE_COLLABORATION;
590 config.SetDistributedType(distributedType);
591 DistributedType retDistributedType = config.GetDistributedType();
592 EXPECT_EQ(distributedType, retDistributedType);
593
594 ConfigTestOpenCallback helper;
595 int errCode = E_ERROR;
596 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
597 EXPECT_NE(store, nullptr);
598 store = nullptr;
599 auto ret = RdbHelper::DeleteRdbStore(dbPath);
600 EXPECT_EQ(ret, E_OK);
601
602 distributedType = DistributedType::RDB_DISTRIBUTED_TYPE_MAX;
603 config.SetDistributedType(distributedType);
604 retDistributedType = config.GetDistributedType();
605 EXPECT_NE(distributedType, retDistributedType);
606
607 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
608 EXPECT_NE(store, nullptr);
609 }
610
611 /**
612 * @tc.name: RdbStoreConfig_018
613 * @tc.desc: test RdbStoreConfig interfaces: SetModuleName/GetModuleName
614 * @tc.type: FUNC
615 */
616 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_018, TestSize.Level1)
617 {
618 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
619 RdbStoreConfig config(dbPath);
620
621 std::string moduleName = "phone";
622 config.SetModuleName(moduleName);
623 std::string retModuleName = config.GetModuleName();
624 EXPECT_EQ(moduleName, retModuleName);
625
626 ConfigTestOpenCallback helper;
627 int errCode = E_ERROR;
628 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
629 EXPECT_NE(store, nullptr);
630 }
631
632 /**
633 * @tc.name: RdbStoreConfig_019
634 * @tc.desc: test RdbStoreConfig interfaces: SetModuleName/GetModuleName
635 * @tc.type: FUNC
636 */
637 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_019, TestSize.Level1)
638 {
639 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
640 RdbStoreConfig config(dbPath);
641
642 std::string serviceName = "com.ohos.config.test";
643 config.SetServiceName(serviceName);
644 std::string retServiceName = config.GetBundleName();
645 EXPECT_EQ(serviceName, retServiceName);
646
647 ConfigTestOpenCallback helper;
648 int errCode = E_ERROR;
649 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
650 EXPECT_NE(store, nullptr);
651 }
652
653 /**
654 * @tc.name: RdbStoreConfig_020
655 * @tc.desc: test RdbStoreConfig interfaces: GetSyncModeValue
656 * @tc.type: FUNC
657 */
658 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_020, TestSize.Level1)
659 {
660 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
661 RdbStoreConfig config(dbPath);
662
663 std::string syncMode = config.GetSyncModeValue(SyncMode::MODE_OFF);
664 EXPECT_EQ(syncMode, "MODE_OFF");
665 syncMode = OHOS::NativeRdb::RdbStoreConfig::GetSyncModeValue(SyncMode::MODE_NORMAL);
666 EXPECT_EQ(syncMode, "MODE_NORMAL");
667 syncMode = config.GetSyncModeValue(SyncMode::MODE_FULL);
668 EXPECT_EQ(syncMode, "MODE_FULL");
669 syncMode = config.GetSyncModeValue(SyncMode::MODE_EXTRA);
670 EXPECT_EQ(syncMode, "MODE_EXTRA");
671 }
672
673 /**
674 * @tc.name: RdbStoreConfig_021
675 * @tc.desc: test RdbStoreConfig interfaces: SetAutoCheck/IsAutoCheck
676 * @tc.type: FUNC
677 */
678 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_021, TestSize.Level1)
679 {
680 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
681 RdbStoreConfig config(dbPath);
682
683 bool autoCheck = true;
684 config.SetAutoCheck(autoCheck);
685 bool retAutoCheck = config.IsAutoCheck();
686 EXPECT_EQ(autoCheck, retAutoCheck);
687
688 ConfigTestOpenCallback helper;
689 int errCode = E_ERROR;
690 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
691 EXPECT_NE(store, nullptr);
692 }
693
694 /**
695 * @tc.name: RdbStoreConfig_022
696 * @tc.desc: test RdbStoreConfig interfaces: SetJournalSize/GetJournalSize
697 * @tc.type: FUNC
698 */
699 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_022, TestSize.Level1)
700 {
701 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
702 RdbStoreConfig config(dbPath);
703
704 static constexpr int journalSize = 2 * 1024 * 1024;
705 config.SetJournalSize(journalSize);
706 int retJournalSize = config.GetJournalSize();
707 EXPECT_EQ(journalSize, retJournalSize);
708
709 ConfigTestOpenCallback helper;
710 int errCode = E_ERROR;
711 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
712 EXPECT_NE(store, nullptr);
713 store = nullptr;
714 auto ret = RdbHelper::DeleteRdbStore(dbPath);
715 EXPECT_EQ(ret, E_OK);
716
717 config.SetJournalSize(0);
718 retJournalSize = config.GetJournalSize();
719 EXPECT_EQ(0, retJournalSize);
720 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
721 EXPECT_NE(store, nullptr);
722 }
723
724 /**
725 * @tc.name: RdbStoreConfig_023
726 * @tc.desc: test RdbStoreConfig interfaces: SetJournalSize/GetJournalSize
727 * @tc.type: FUNC
728 */
729 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_023, TestSize.Level1)
730 {
731 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
732 RdbStoreConfig config(dbPath);
733
734 static constexpr int pageSize = 4 * 1024;
735 config.SetPageSize(pageSize);
736 int retPageSize = config.GetPageSize();
737 EXPECT_EQ(pageSize, retPageSize);
738
739 ConfigTestOpenCallback helper;
740 int errCode = E_ERROR;
741 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
742 EXPECT_NE(store, nullptr);
743 store = nullptr;
744 auto ret = RdbHelper::DeleteRdbStore(dbPath);
745 EXPECT_EQ(ret, E_OK);
746
747 config.SetPageSize(0);
748 retPageSize = config.GetPageSize();
749 EXPECT_EQ(0, retPageSize);
750 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
751 EXPECT_NE(store, nullptr);
752 }
753
754 /**
755 * @tc.name: RdbStoreConfig_024
756 * @tc.desc: test RdbStoreConfig interfaces: SetEncryptAlgo/GetEncryptAlgo
757 * @tc.type: FUNC
758 */
759 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_024, TestSize.Level1)
760 {
761 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
762 RdbStoreConfig config(dbPath);
763
764 std::string encryptAlgo = "sha256";
765 config.SetEncryptAlgo(encryptAlgo);
766 std::string retEncryptAlgo = config.GetEncryptAlgo();
767 EXPECT_EQ(encryptAlgo, retEncryptAlgo);
768
769 ConfigTestOpenCallback helper;
770 int errCode = E_ERROR;
771 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
772 EXPECT_NE(store, nullptr);
773 store = nullptr;
774 auto ret = RdbHelper::DeleteRdbStore(dbPath);
775 EXPECT_EQ(ret, E_OK);
776
777 config.SetEncryptAlgo("");
778 retEncryptAlgo = config.GetEncryptAlgo();
779 EXPECT_EQ("", retEncryptAlgo);
780 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
781 EXPECT_NE(store, nullptr);
782 }
783
784 /**
785 * @tc.name: RdbStoreConfig_025
786 * @tc.desc: test RdbStoreConfig interfaces: SetReadConSize/GetReadConSize
787 * @tc.type: FUNC
788 */
789 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_025, TestSize.Level1)
790 {
791 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
792 RdbStoreConfig config(dbPath);
793
794 static constexpr int readConSize = 4;
795 int retReadConSize = config.GetReadConSize();
796 EXPECT_EQ(readConSize, retReadConSize);
797
798 ConfigTestOpenCallback helper;
799 int errCode = E_ERROR;
800 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
801 EXPECT_NE(store, nullptr);
802 store = nullptr;
803 auto ret = RdbHelper::DeleteRdbStore(dbPath);
804 EXPECT_EQ(ret, E_OK);
805
806 config.SetReadConSize(20);
807 retReadConSize = config.GetReadConSize();
808 EXPECT_EQ(20, retReadConSize);
809 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
810 EXPECT_NE(store, nullptr);
811 store = nullptr;
812 ret = RdbHelper::DeleteRdbStore(dbPath);
813 EXPECT_EQ(ret, E_OK);
814
815 config.SetReadConSize(0);
816 retReadConSize = config.GetReadConSize();
817 EXPECT_EQ(0, retReadConSize);
818 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
819 EXPECT_NE(store, nullptr);
820 store = nullptr;
821 ret = RdbHelper::DeleteRdbStore(dbPath);
822 EXPECT_EQ(ret, E_OK);
823
824 config.SetReadConSize(1);
825 retReadConSize = config.GetReadConSize();
826 EXPECT_EQ(1, retReadConSize);
827 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
828 EXPECT_NE(store, nullptr);
829 store = nullptr;
830 ret = RdbHelper::DeleteRdbStore(dbPath);
831 EXPECT_EQ(ret, E_OK);
832
833 config.SetReadConSize(64);
834 retReadConSize = config.GetReadConSize();
835 EXPECT_EQ(64, retReadConSize);
836 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
837 EXPECT_NE(store, nullptr);
838 }
839
840 /**
841 * @tc.name: RdbStoreConfig_026
842 * @tc.desc: test RdbStoreConfig interfaces: SetReadConSize/GetReadConSize
843 * @tc.type: FUNC
844 */
845 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_026, TestSize.Level1)
846 {
847 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
848 RdbStoreConfig config(dbPath);
849
850 static constexpr int readConSize = 10;
851 config.SetReadConSize(readConSize);
852 int retReadConSize = config.GetReadConSize();
853 EXPECT_EQ(readConSize, retReadConSize);
854
855 ConfigTestOpenCallback helper;
856 int errCode = E_ERROR;
857 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
858 EXPECT_NE(store, nullptr);
859 EXPECT_EQ(errCode, E_OK);
860
861 int64_t id;
862 ValuesBucket values;
863 values.PutInt("id", 1);
864 values.PutString("name", std::string("zhangsan"));
865 values.PutInt("age", 18);
866 values.PutDouble("salary", 100.5);
867 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
868 int ret = store->Insert(id, "test", values);
869 EXPECT_EQ(ret, E_OK);
870 EXPECT_EQ(1, id);
871
872 std::vector<std::shared_ptr<ResultSet>> resultSets;
873 for (int i = 0; i < readConSize; ++i) {
874 auto resultSet = store->QueryByStep("SELECT * FROM test");
875 EXPECT_NE(resultSet, nullptr);
876 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
877 resultSets.push_back(resultSet);
878 }
879 for (const auto &resultSet : resultSets) {
880 EXPECT_EQ(E_OK, resultSet->Close());
881 }
882 store = nullptr;
883 }
884
885 /**
886 * @tc.name: RdbStoreConfig_027
887 * @tc.desc: test RdbStoreConfig interfaces: SetDataGroupId/GetDataGroupId
888 * @tc.type: FUNC
889 */
890 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_027, TestSize.Level1)
891 {
892 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
893 RdbStoreConfig config(dbPath);
894
895 std::string dataGroupId = "123456";
896 config.SetDataGroupId(dataGroupId);
897 EXPECT_EQ(dataGroupId, config.GetDataGroupId());
898 }
899
900 /**
901 * @tc.name: RdbStoreConfig_028
902 * @tc.desc: test RdbStoreConfig interfaces: SetDataGroupId/SetAutoClean
903 * @tc.type: FUNC
904 */
905 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_028, TestSize.Level1)
906 {
907 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
908 RdbStoreConfig config(dbPath);
909
910 bool autoClean = false;
911 config.SetAutoClean(autoClean);
912 EXPECT_EQ(autoClean, config.GetAutoClean());
913 }
914
915 /**
916 * @tc.name: RdbStoreConfig_029
917 * @tc.desc: test RdbStoreConfig interfaces: SetModuleName/GetModuleName
918 * @tc.type: FUNC
919 */
920 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_029, TestSize.Level1)
921 {
922 const std::string dbPath = RDB_TEST_PATH + "config_test_29.db";
923 RdbStoreConfig config(dbPath);
924
925 std::string bundleName = "com.ohos.config.test30";
926 config.SetBundleName(bundleName);
927 config.SetSecurityLevel(SecurityLevel::S2);
928 config.SetArea(0);
929 config.SetEncryptStatus(false);
930
931 ConfigTestOpenCallback helper;
932 int errCode = E_ERROR;
933 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
934 EXPECT_EQ(errCode, E_OK);
935 EXPECT_NE(store, nullptr);
936
937 store = nullptr;
938
939 auto invalidConfig = config;
940 invalidConfig.SetSecurityLevel(SecurityLevel::S1);
941 store = RdbHelper::GetRdbStore(invalidConfig, 1, helper, errCode);
942 EXPECT_EQ(errCode, E_CONFIG_INVALID_CHANGE);
943 EXPECT_EQ(store, nullptr);
944 store = nullptr;
945
946 RdbHelper::DeleteRdbStore(dbPath);
947 }
948
949 /**
950 * @tc.name: RdbStoreConfig_030
951 * @tc.desc: test RdbStoreConfig interfaces: SetReadTime/GetReadTime
952 * @tc.type: FUNC
953 */
954 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_030, TestSize.Level1)
955 {
956 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
957 RdbStoreConfig config(dbPath);
958
959 int timeout = 10;
960 config.SetReadTime(timeout);
961 EXPECT_EQ(timeout, config.GetReadTime());
962
963 // 0 is used to test the situation when outTime is less than MIN_TIMEOUT.
964 timeout = 0;
965 config.SetReadTime(timeout);
966 EXPECT_EQ(1, config.GetReadTime());
967
968 // 301 is used to test the situation when outTime is greater than MAX_TIMEOUT.
969 timeout = 301;
970 config.SetReadTime(timeout);
971 EXPECT_EQ(300, config.GetReadTime());
972 }
973
974 /**
975 * @tc.name: RdbStoreConfig_031
976 * @tc.desc: test RdbStoreConfig interfaces: SetDataGroupId/SetAutoClean
977 * @tc.type: FUNC
978 */
979 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_031, TestSize.Level1)
980 {
981 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
982 RdbStoreConfig config(dbPath);
983
984 bool allowRebuild = false;
985 config.SetAllowRebuild(allowRebuild);
986 EXPECT_EQ(allowRebuild, config.GetAllowRebuild());
987
988 allowRebuild = true;
989 config.SetAllowRebuild(allowRebuild);
990 EXPECT_EQ(allowRebuild, config.GetAllowRebuild());
991 }
992
993 /**
994 * @tc.name: RdbStoreConfig_032
995 * @tc.desc: test RdbStoreConfig interfaces: SetWriteTime/GetWriteTime
996 * @tc.type: FUNC
997 */
998 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_032, TestSize.Level1)
999 {
1000 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
1001 RdbStoreConfig config(dbPath);
1002
1003 int timeout = 10;
1004 config.SetWriteTime(timeout);
1005 EXPECT_EQ(timeout, config.GetWriteTime());
1006
1007 // 0 is used to test the situation when outTime is less than MIN_TIMEOUT.
1008 timeout = 0;
1009 config.SetWriteTime(timeout);
1010 EXPECT_EQ(1, config.GetWriteTime());
1011
1012 // 301 is used to test the situation when outTime is greater than MAX_TIMEOUT.
1013 timeout = 301;
1014 config.SetWriteTime(timeout);
1015 EXPECT_EQ(300, config.GetWriteTime());
1016 }
1017
1018 /**
1019 * @tc.name: RdbStoreConfig_033
1020 * @tc.desc: test RdbStoreConfig SetSecurityLevel S2->S1
1021 * @tc.type: FUNC
1022 */
1023 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_033, TestSize.Level1)
1024 {
1025 const std::string dbPath = RDB_TEST_PATH + "config_test_33.db";
1026 RdbStoreConfig config(dbPath);
1027
1028 std::string bundleName = "com.ohos.config.test33";
1029 config.SetBundleName(bundleName);
1030 config.SetSecurityLevel(SecurityLevel::S2);
1031
1032 ConfigTestOpenCallback helper;
1033 int errCode = E_ERROR;
1034 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
1035 EXPECT_EQ(errCode, E_OK);
1036 EXPECT_NE(store, nullptr);
1037
1038 store = nullptr;
1039
1040 auto invalidConfig = config;
1041 invalidConfig.SetSecurityLevel(SecurityLevel::S1);
1042 store = RdbHelper::GetRdbStore(invalidConfig, 1, helper, errCode);
1043 EXPECT_EQ(errCode, E_CONFIG_INVALID_CHANGE);
1044 EXPECT_EQ(store, nullptr);
1045 store = nullptr;
1046
1047 RdbHelper::DeleteRdbStore(dbPath);
1048 }
1049
1050 /**
1051 * @tc.name: RdbStoreConfigVisitor_001
1052 * @tc.desc: test RdbStoreConfigVisitor
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(RdbStoreConfigTest, RdbStoreConfigVisitor_001, TestSize.Level1)
1056 {
1057 int errCode = E_OK;
1058 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
1059 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
1060 ConfigTestOpenCallback helper;
1061 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
1062 EXPECT_NE(store, nullptr);
1063 EXPECT_EQ(errCode, E_OK);
1064
1065 const std::string visitorDir = RDB_TEST_PATH + "config_test.db";
1066 RdbStoreConfig visitorConfig("", StorageMode::MODE_DISK, true);
1067 ConfigTestVisitorOpenCallback visitorHelper;
1068 visitorConfig.SetRoleType(OHOS::NativeRdb::VISITOR);
1069 visitorConfig.SetVisitorDir(visitorDir);
1070 visitorConfig.SetCreateNecessary(false);
1071 std::shared_ptr<RdbStore> visitorStore = RdbHelper::GetRdbStore(visitorConfig, 1, visitorHelper, errCode);
1072 EXPECT_NE(visitorStore, nullptr);
1073 EXPECT_EQ(errCode, E_OK);
1074 EXPECT_EQ(visitorDir, visitorConfig.GetVisitorDir());
1075
1076 int64_t id;
1077 ValuesBucket values;
1078 values.PutInt("id", 1);
1079 values.PutString("name", std::string("zhangsan"));
1080 values.PutInt("age", 18);
1081 values.PutDouble("salary", 100.5);
1082 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
1083 int ret = visitorStore->Insert(id, "test", values);
1084 EXPECT_NE(ret, E_OK);
1085
1086 store = nullptr;
1087 visitorStore = nullptr;
1088 ret = RdbHelper::DeleteRdbStore(dbPath);
1089 EXPECT_EQ(ret, E_OK);
1090 }