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     EncryptAlgo encryptAlgo = EncryptAlgo::AES_256_GCM;
765     config.SetEncryptAlgo(encryptAlgo);
766     EncryptAlgo 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 
778 /**
779  * @tc.name: RdbStoreConfig_025
780  * @tc.desc: test RdbStoreConfig interfaces: SetReadConSize/GetReadConSize
781  * @tc.type: FUNC
782  */
783 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_025, TestSize.Level1)
784 {
785     const std::string dbPath = RDB_TEST_PATH + "config_test.db";
786     RdbStoreConfig config(dbPath);
787 
788     static constexpr int readConSize = 4;
789     int retReadConSize = config.GetReadConSize();
790     EXPECT_EQ(readConSize, retReadConSize);
791 
792     ConfigTestOpenCallback helper;
793     int errCode = E_ERROR;
794     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
795     EXPECT_NE(store, nullptr);
796     store = nullptr;
797     auto ret = RdbHelper::DeleteRdbStore(dbPath);
798     EXPECT_EQ(ret, E_OK);
799 
800     config.SetReadConSize(20);
801     retReadConSize = config.GetReadConSize();
802     EXPECT_EQ(20, retReadConSize);
803     store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
804     EXPECT_NE(store, nullptr);
805     store = nullptr;
806     ret = RdbHelper::DeleteRdbStore(dbPath);
807     EXPECT_EQ(ret, E_OK);
808 
809     config.SetReadConSize(0);
810     retReadConSize = config.GetReadConSize();
811     EXPECT_EQ(0, retReadConSize);
812     store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
813     EXPECT_NE(store, nullptr);
814     store = nullptr;
815     ret = RdbHelper::DeleteRdbStore(dbPath);
816     EXPECT_EQ(ret, E_OK);
817 
818     config.SetReadConSize(1);
819     retReadConSize = config.GetReadConSize();
820     EXPECT_EQ(1, retReadConSize);
821     store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
822     EXPECT_NE(store, nullptr);
823     store = nullptr;
824     ret = RdbHelper::DeleteRdbStore(dbPath);
825     EXPECT_EQ(ret, E_OK);
826 
827     config.SetReadConSize(64);
828     retReadConSize = config.GetReadConSize();
829     EXPECT_EQ(64, retReadConSize);
830     store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
831     EXPECT_NE(store, nullptr);
832 }
833 
834 /**
835  * @tc.name: RdbStoreConfig_026
836  * @tc.desc: test RdbStoreConfig interfaces: SetReadConSize/GetReadConSize
837  * @tc.type: FUNC
838  */
839 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_026, TestSize.Level1)
840 {
841     const std::string dbPath = RDB_TEST_PATH + "config_test.db";
842     RdbStoreConfig config(dbPath);
843 
844     static constexpr int readConSize = 10;
845     config.SetReadConSize(readConSize);
846     int retReadConSize = config.GetReadConSize();
847     EXPECT_EQ(readConSize, retReadConSize);
848 
849     ConfigTestOpenCallback helper;
850     int errCode = E_ERROR;
851     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
852     EXPECT_NE(store, nullptr);
853     EXPECT_EQ(errCode, E_OK);
854 
855     int64_t id;
856     ValuesBucket values;
857     values.PutInt("id", 1);
858     values.PutString("name", std::string("zhangsan"));
859     values.PutInt("age", 18);
860     values.PutDouble("salary", 100.5);
861     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
862     int ret = store->Insert(id, "test", values);
863     EXPECT_EQ(ret, E_OK);
864     EXPECT_EQ(1, id);
865 
866     std::vector<std::shared_ptr<ResultSet>> resultSets;
867     for (int i = 0; i < readConSize; ++i) {
868         auto resultSet = store->QueryByStep("SELECT * FROM test");
869         EXPECT_NE(resultSet, nullptr);
870         EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
871         resultSets.push_back(resultSet);
872     }
873     for (const auto &resultSet : resultSets) {
874         EXPECT_EQ(E_OK, resultSet->Close());
875     }
876     store = nullptr;
877 }
878 
879 /**
880  * @tc.name: RdbStoreConfig_027
881  * @tc.desc: test RdbStoreConfig interfaces: SetDataGroupId/GetDataGroupId
882  * @tc.type: FUNC
883  */
884 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_027, TestSize.Level1)
885 {
886     const std::string dbPath = RDB_TEST_PATH + "config_test.db";
887     RdbStoreConfig config(dbPath);
888 
889     std::string dataGroupId = "123456";
890     config.SetDataGroupId(dataGroupId);
891     EXPECT_EQ(dataGroupId, config.GetDataGroupId());
892 }
893 
894 /**
895  * @tc.name: RdbStoreConfig_028
896  * @tc.desc: test RdbStoreConfig interfaces: SetDataGroupId/SetAutoClean
897  * @tc.type: FUNC
898  */
899 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_028, TestSize.Level1)
900 {
901     const std::string dbPath = RDB_TEST_PATH + "config_test.db";
902     RdbStoreConfig config(dbPath);
903 
904     bool autoClean = false;
905     config.SetAutoClean(autoClean);
906     EXPECT_EQ(autoClean, config.GetAutoClean());
907 }
908 
909 /**
910  * @tc.name: RdbStoreConfig_029
911  * @tc.desc: test RdbStoreConfig interfaces: SetModuleName/GetModuleName
912  * @tc.type: FUNC
913  */
914 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_029, TestSize.Level1)
915 {
916     const std::string dbPath = RDB_TEST_PATH + "config_test_29.db";
917     RdbStoreConfig config(dbPath);
918 
919     std::string bundleName = "com.ohos.config.test30";
920     config.SetBundleName(bundleName);
921     config.SetSecurityLevel(SecurityLevel::S2);
922     config.SetArea(0);
923     config.SetEncryptStatus(false);
924 
925     ConfigTestOpenCallback helper;
926     int errCode = E_ERROR;
927     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
928     EXPECT_EQ(errCode, E_OK);
929     EXPECT_NE(store, nullptr);
930 
931     store = nullptr;
932 
933     auto invalidConfig = config;
934     invalidConfig.SetSecurityLevel(SecurityLevel::S1);
935     store = RdbHelper::GetRdbStore(invalidConfig, 1, helper, errCode);
936     EXPECT_EQ(errCode, E_CONFIG_INVALID_CHANGE);
937     EXPECT_EQ(store, nullptr);
938     store = nullptr;
939 
940     RdbHelper::DeleteRdbStore(dbPath);
941 }
942 
943 /**
944  * @tc.name: RdbStoreConfig_030
945  * @tc.desc: test RdbStoreConfig interfaces: SetReadTime/GetReadTime
946  * @tc.type: FUNC
947  */
948 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_030, TestSize.Level1)
949 {
950     const std::string dbPath = RDB_TEST_PATH + "config_test.db";
951     RdbStoreConfig config(dbPath);
952 
953     int timeout = 10;
954     config.SetReadTime(timeout);
955     EXPECT_EQ(timeout, config.GetReadTime());
956 
957     // 0 is used to test the situation when outTime is less than MIN_TIMEOUT.
958     timeout = 0;
959     config.SetReadTime(timeout);
960     EXPECT_EQ(1, config.GetReadTime());
961 
962     // 301 is used to test the situation when outTime is greater than MAX_TIMEOUT.
963     timeout = 301;
964     config.SetReadTime(timeout);
965     EXPECT_EQ(300, config.GetReadTime());
966 }
967 
968 /**
969  * @tc.name: RdbStoreConfig_031
970  * @tc.desc: test RdbStoreConfig interfaces: SetDataGroupId/SetAutoClean
971  * @tc.type: FUNC
972  */
973 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_031, TestSize.Level1)
974 {
975     const std::string dbPath = RDB_TEST_PATH + "config_test.db";
976     RdbStoreConfig config(dbPath);
977 
978     bool allowRebuild = false;
979     config.SetAllowRebuild(allowRebuild);
980     EXPECT_EQ(allowRebuild, config.GetAllowRebuild());
981 
982     allowRebuild = true;
983     config.SetAllowRebuild(allowRebuild);
984     EXPECT_EQ(allowRebuild, config.GetAllowRebuild());
985 }
986 
987 /**
988  * @tc.name: RdbStoreConfig_032
989  * @tc.desc: test RdbStoreConfig interfaces: SetWriteTime/GetWriteTime
990  * @tc.type: FUNC
991  */
992 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_032, TestSize.Level1)
993 {
994     const std::string dbPath = RDB_TEST_PATH + "config_test.db";
995     RdbStoreConfig config(dbPath);
996 
997     int timeout = 10;
998     config.SetWriteTime(timeout);
999     EXPECT_EQ(timeout, config.GetWriteTime());
1000 
1001     // 0 is used to test the situation when outTime is less than MIN_TIMEOUT.
1002     timeout = 0;
1003     config.SetWriteTime(timeout);
1004     EXPECT_EQ(1, config.GetWriteTime());
1005 
1006     // 301 is used to test the situation when outTime is greater than MAX_TIMEOUT.
1007     timeout = 301;
1008     config.SetWriteTime(timeout);
1009     EXPECT_EQ(300, config.GetWriteTime());
1010 }
1011 
1012 /**
1013  * @tc.name: RdbStoreConfig_033
1014  * @tc.desc: test RdbStoreConfig SetSecurityLevel S2->S1
1015  * @tc.type: FUNC
1016  */
1017 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_033, TestSize.Level1)
1018 {
1019     const std::string dbPath = RDB_TEST_PATH + "config_test_33.db";
1020     RdbStoreConfig config(dbPath);
1021 
1022     std::string bundleName = "com.ohos.config.test33";
1023     config.SetBundleName(bundleName);
1024     config.SetSecurityLevel(SecurityLevel::S2);
1025 
1026     ConfigTestOpenCallback helper;
1027     int errCode = E_ERROR;
1028     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
1029     EXPECT_EQ(errCode, E_OK);
1030     EXPECT_NE(store, nullptr);
1031 
1032     store = nullptr;
1033 
1034     auto invalidConfig = config;
1035     invalidConfig.SetSecurityLevel(SecurityLevel::S1);
1036     store = RdbHelper::GetRdbStore(invalidConfig, 1, helper, errCode);
1037     EXPECT_EQ(errCode, E_CONFIG_INVALID_CHANGE);
1038     EXPECT_EQ(store, nullptr);
1039     store = nullptr;
1040 
1041     RdbHelper::DeleteRdbStore(dbPath);
1042 }
1043 
1044 /**
1045  * @tc.name: RdbStoreConfigVisitor_001
1046  * @tc.desc: test RdbStoreConfigVisitor
1047  * @tc.type: FUNC
1048  */
1049 HWTEST_F(RdbStoreConfigTest, RdbStoreConfigVisitor_001, TestSize.Level1)
1050 {
1051     int errCode = E_OK;
1052     const std::string dbPath = RDB_TEST_PATH + "config_test.db";
1053     RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
1054     ConfigTestOpenCallback helper;
1055     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
1056     EXPECT_NE(store, nullptr);
1057     EXPECT_EQ(errCode, E_OK);
1058 
1059     const std::string visitorDir = RDB_TEST_PATH + "config_test.db";
1060     RdbStoreConfig visitorConfig("", StorageMode::MODE_DISK, true);
1061     ConfigTestVisitorOpenCallback visitorHelper;
1062     visitorConfig.SetRoleType(OHOS::NativeRdb::VISITOR);
1063     visitorConfig.SetVisitorDir(visitorDir);
1064     visitorConfig.SetCreateNecessary(false);
1065     std::shared_ptr<RdbStore> visitorStore = RdbHelper::GetRdbStore(visitorConfig, 1, visitorHelper, errCode);
1066     EXPECT_NE(visitorStore, nullptr);
1067     EXPECT_EQ(errCode, E_OK);
1068     EXPECT_EQ(visitorDir, visitorConfig.GetVisitorDir());
1069 
1070     int64_t id;
1071     ValuesBucket values;
1072     values.PutInt("id", 1);
1073     values.PutString("name", std::string("zhangsan"));
1074     values.PutInt("age", 18);
1075     values.PutDouble("salary", 100.5);
1076     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
1077     int ret = visitorStore->Insert(id, "test", values);
1078     EXPECT_NE(ret, E_OK);
1079 
1080     store = nullptr;
1081     visitorStore = nullptr;
1082     ret = RdbHelper::DeleteRdbStore(dbPath);
1083     EXPECT_EQ(ret, E_OK);
1084 }