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::NativeRdb;
29
30 class RdbStoreConfigTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36 };
37
38 class ConfigTestOpenCallback : public RdbOpenCallback {
39 public:
40 int OnCreate(RdbStore &rdbStore) override;
41 int OnUpgrade(RdbStore &rdbStore, int oldVersion, int newVersion) override;
42 static const std::string CREATE_TABLE_TEST;
43 };
44
45 const std::string ConfigTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
46 + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
47 "name TEXT NOT NULL, age INTEGER, salary "
48 "REAL, blobType BLOB)");
49
OnCreate(RdbStore & store)50 int ConfigTestOpenCallback::OnCreate(RdbStore &store)
51 {
52 return store.ExecuteSql(CREATE_TABLE_TEST);
53 }
54
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)55 int ConfigTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
56 {
57 return E_OK;
58 }
59
SetUpTestCase(void)60 void RdbStoreConfigTest::SetUpTestCase(void)
61 {
62 }
63
TearDownTestCase(void)64 void RdbStoreConfigTest::TearDownTestCase(void)
65 {
66 RdbHelper::DeleteRdbStore(RDB_TEST_PATH + "config_test.db");
67 }
68
SetUp(void)69 void RdbStoreConfigTest::SetUp(void)
70 {
71 }
72
TearDown(void)73 void RdbStoreConfigTest::TearDown(void)
74 {
75 RdbHelper::ClearCache();
76 }
77
78 /**
79 * @tc.name: RdbStoreConfig_001
80 * @tc.desc: test RdbStoreConfig
81 * @tc.type: FUNC
82 * @tc.require: AR000CU2BO
83 * @tc.author: chenxi
84 */
85 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_001, TestSize.Level1)
86 {
87 int errCode = E_OK;
88 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
89 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
90 ConfigTestOpenCallback helper;
91 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
92 EXPECT_NE(store, nullptr);
93 EXPECT_EQ(errCode, E_OK);
94
95 int64_t id;
96 ValuesBucket values;
97 values.PutInt("id", 1);
98 values.PutString("name", std::string("zhangsan"));
99 values.PutInt("age", 18);
100 values.PutDouble("salary", 100.5);
101 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
102 int ret = store->Insert(id, "test", values);
103 EXPECT_EQ(ret, E_OK);
104 EXPECT_EQ(1, id);
105
106 ret = access(dbPath.c_str(), F_OK);
107 EXPECT_EQ(ret, 0);
108
109 int currentVersion;
110 ret = store->GetVersion(currentVersion);
111 EXPECT_EQ(ret, E_OK);
112 EXPECT_EQ(1, currentVersion);
113
114 store = nullptr;
115 ret = RdbHelper::DeleteRdbStore(dbPath);
116 EXPECT_EQ(ret, E_OK);
117
118 StorageMode mode = config.GetStorageMode();
119 StorageMode targeMode = StorageMode::MODE_DISK;
120 EXPECT_EQ(mode, targeMode);
121 }
122
123 /**
124 * @tc.name: RdbStoreConfig_002
125 * @tc.desc: test RdbStoreConfig
126 * @tc.type: FUNC
127 * @tc.require: AR000CU2BO
128 * @tc.author: chenxi
129 */
130 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_002, TestSize.Level1)
131 {
132 int errCode = E_OK;
133 RdbStoreConfig config("", StorageMode::MODE_MEMORY);
134 ConfigTestOpenCallback helper;
135 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
136 EXPECT_NE(store, nullptr);
137 EXPECT_EQ(errCode, E_OK);
138
139 int64_t id;
140 ValuesBucket values;
141 values.PutInt("id", 1);
142 values.PutString("name", std::string("zhangsan"));
143 values.PutInt("age", 18);
144 values.PutDouble("salary", 100.5);
145 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
146 int ret = store->Insert(id, "test", values);
147 EXPECT_EQ(ret, E_OK);
148 EXPECT_EQ(1, id);
149
150 int currentVersion;
151 ret = store->GetVersion(currentVersion);
152 EXPECT_EQ(ret, E_OK);
153 EXPECT_EQ(1, currentVersion);
154
155 store->SetVersion(5);
156 ret = store->GetVersion(currentVersion);
157 EXPECT_EQ(ret, E_OK);
158 EXPECT_EQ(5, currentVersion);
159
160 store->SetVersion(2147483647);
161 ret = store->GetVersion(currentVersion);
162 EXPECT_EQ(ret, E_OK);
163 EXPECT_EQ(2147483647, currentVersion);
164
165 store->SetVersion(-2147483648);
166 ret = store->GetVersion(currentVersion);
167 EXPECT_EQ(ret, E_OK);
168 EXPECT_EQ(-2147483648, currentVersion);
169
170 std::string journalMode;
171 ret = store->ExecuteAndGetString(journalMode, "PRAGMA journal_mode");
172 EXPECT_EQ(ret, E_OK);
173 EXPECT_EQ(journalMode, "memory");
174
175 StorageMode mode = config.GetStorageMode();
176 StorageMode targeMode = StorageMode::MODE_MEMORY;
177 EXPECT_EQ(mode, targeMode);
178 }
179
180 /**
181 * @tc.name: RdbStoreConfig_003
182 * @tc.desc: test RdbStoreConfig
183 * @tc.type: FUNC
184 * @tc.require: AR000CU2BO
185 * @tc.author: chenxi
186 */
187 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_003, TestSize.Level1)
188 {
189 int errCode = E_OK;
190 RdbStoreConfig config("", StorageMode::MODE_DISK, false);
191 ConfigTestOpenCallback helper;
192 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
193 EXPECT_EQ(store, nullptr);
194 EXPECT_EQ(errCode, E_EMPTY_FILE_NAME);
195 }
196
197 /**
198 * @tc.name: RdbStoreConfig_004
199 * @tc.desc: test RdbStoreConfig
200 * @tc.type: FUNC
201 * @tc.require: AR000CU2BO
202 * @tc.author: chenxi
203 */
204 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_004, TestSize.Level1)
205 {
206 int errCode = E_OK;
207 const std::string dbPath = "config_test.db";
208 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
209 ConfigTestOpenCallback helper;
210 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
211 EXPECT_EQ(store, nullptr);
212 EXPECT_EQ(errCode, E_RELATIVE_PATH);
213 }
214
215 /**
216 * @tc.name: RdbStoreConfig_005
217 * @tc.desc: test RdbStoreConfig journalMode
218 * @tc.type: FUNC
219 * @tc.require: AR000CU2BO
220 * @tc.author: chenxi
221 */
222 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_005, TestSize.Level1)
223 {
224 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
225 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
226 std::string journalMode = config.GetJournalMode();
227 EXPECT_EQ(journalMode, "");
228 ConfigTestOpenCallback helper;
229 int errCode = E_OK;
230 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
231 EXPECT_NE(store, nullptr);
232
233 std::string currentMode;
234 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
235 EXPECT_EQ(ret, E_OK);
236 EXPECT_EQ(currentMode, "wal");
237 }
238
239 /**
240 * @tc.name: RdbStoreConfig_006
241 * @tc.desc: test RdbStoreConfig journalMode
242 * @tc.type: FUNC
243 * @tc.require: AR000CU2BO
244 * @tc.author: chenxi
245 */
246 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_006, TestSize.Level1)
247 {
248 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
249 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
250 config.SetJournalMode(JournalMode::MODE_DELETE);
251 std::string journalMode = config.GetJournalMode();
252 EXPECT_EQ(journalMode, "DELETE");
253 ConfigTestOpenCallback helper;
254 int errCode = E_OK;
255 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
256 EXPECT_NE(store, nullptr);
257
258 std::string currentMode;
259 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
260 EXPECT_EQ(ret, E_OK);
261 EXPECT_EQ(currentMode, "delete");
262 }
263
264 /**
265 * @tc.name: RdbStoreConfig_007
266 * @tc.desc: test RdbStoreConfig journalMode
267 * @tc.type: FUNC
268 * @tc.require: AR000CU2BO
269 * @tc.author: chenxi
270 */
271 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_007, TestSize.Level1)
272 {
273 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
274 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
275 config.SetJournalMode(JournalMode::MODE_TRUNCATE);
276 std::string journalMode = config.GetJournalMode();
277 EXPECT_EQ(journalMode, "TRUNCATE");
278 ConfigTestOpenCallback helper;
279 int errCode = E_OK;
280 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
281 EXPECT_NE(store, nullptr);
282
283 std::string currentMode;
284 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
285 EXPECT_EQ(ret, E_OK);
286 EXPECT_EQ(currentMode, "truncate");
287 }
288
289 /**
290 * @tc.name: RdbStoreConfig_008
291 * @tc.desc: test RdbStoreConfig journalMode
292 * @tc.type: FUNC
293 * @tc.require: AR000CU2BO
294 * @tc.author: chenxi
295 */
296 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_008, TestSize.Level1)
297 {
298 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
299 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
300 config.SetJournalMode(JournalMode::MODE_PERSIST);
301 std::string journalMode = config.GetJournalMode();
302 EXPECT_EQ(journalMode, "PERSIST");
303 ConfigTestOpenCallback helper;
304 int errCode = E_OK;
305 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
306 EXPECT_NE(store, nullptr);
307
308 std::string currentMode;
309 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
310 EXPECT_EQ(ret, E_OK);
311 EXPECT_EQ(currentMode, "persist");
312 }
313
314 /**
315 * @tc.name: RdbStoreConfig_009
316 * @tc.desc: test RdbStoreConfig journalMode
317 * @tc.type: FUNC
318 * @tc.require: AR000CU2BO
319 * @tc.author: chenxi
320 */
321 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_009, TestSize.Level1)
322 {
323 LOG_INFO("RdbStoreConfig_007 start");
324 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
325 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
326 config.SetJournalMode(JournalMode::MODE_MEMORY);
327 std::string journalMode = config.GetJournalMode();
328 EXPECT_EQ(journalMode, "MEMORY");
329 ConfigTestOpenCallback helper;
330 int errCode = E_OK;
331 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
332 EXPECT_NE(store, nullptr);
333
334 std::string currentMode;
335 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
336 EXPECT_EQ(ret, E_OK);
337 EXPECT_EQ(currentMode, "memory");
338 }
339 /**
340 * @tc.name: RdbStoreConfig_010
341 * @tc.desc: test RdbStoreConfig journalMode
342 * @tc.type: FUNC
343 * @tc.require: AR000CU2BO
344 * @tc.author: chenxi
345 */
346 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_010, TestSize.Level1)
347 {
348 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
349 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
350 config.SetJournalMode(JournalMode::MODE_WAL);
351 std::string journalMode = config.GetJournalMode();
352 EXPECT_EQ(journalMode, "WAL");
353 ConfigTestOpenCallback helper;
354 int errCode = E_OK;
355 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
356 EXPECT_NE(store, nullptr);
357
358 std::string currentMode;
359 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
360 EXPECT_EQ(ret, E_OK);
361 EXPECT_EQ(currentMode, "wal");
362 }
363
364 /**
365 * @tc.name: RdbStoreConfig_011
366 * @tc.desc: test RdbStoreConfig journalMode
367 * @tc.type: FUNC
368 * @tc.require: AR000CU2BO
369 * @tc.author: chenxi
370 */
371 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_011, TestSize.Level1)
372 {
373 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
374 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
375 config.SetJournalMode(JournalMode::MODE_OFF);
376 std::string journalMode = config.GetJournalMode();
377 EXPECT_EQ(journalMode, "OFF");
378 ConfigTestOpenCallback helper;
379 int errCode = E_OK;
380 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
381 EXPECT_NE(store, nullptr);
382
383 std::string currentMode;
384 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
385 EXPECT_EQ(ret, E_OK);
386 EXPECT_EQ(currentMode, "off");
387 }
388
389 /**
390 * @tc.name: RdbStoreConfig_012
391 * @tc.desc: test RdbStoreConfig SetReadPermission/GetReadPermission/SetWritePermission/GetWritePermission
392 * @tc.type: FUNC
393 * @tc.require: AR000CU2BO
394 * @tc.author: chenxi
395 */
396 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_012, TestSize.Level1)
397 {
398 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
399 RdbStoreConfig config(dbPath);
400
401 std::string readPermission = "readPermission";
402 config.SetReadPermission(readPermission);
403 std::string getReadPermission = config.GetReadPermission();
404 EXPECT_EQ(getReadPermission, readPermission);
405
406 std::string writePermission = "writePermission";
407 config.SetWritePermission(writePermission);
408 std::string getWritePermission = config.GetWritePermission();
409 EXPECT_EQ(getWritePermission, writePermission);
410
411 std::string uri = "uri";
412 config.SetUri(uri);
413 std::string getUri = config.GetUri();
414 EXPECT_EQ(getUri, uri);
415
416 SecurityLevel securityLevel = SecurityLevel::S1;
417 config.SetSecurityLevel(securityLevel);
418 SecurityLevel getSecurityLevel = config.GetSecurityLevel();
419 EXPECT_EQ(getSecurityLevel, securityLevel);
420 }
421
422 /**
423 * @tc.name: RdbStoreConfig_013
424 * @tc.desc: test RdbStoreConfig interfaces: SetSecurityLevel/GetSecurityLevel
425 * @tc.type: FUNC
426 * @tc.require:
427 * @tc.author:
428 */
429 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_013, TestSize.Level1)
430 {
431 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
432 RdbStoreConfig config(dbPath);
433
434 config.SetSecurityLevel(SecurityLevel::S2);
435 SecurityLevel retSecurityLevel = config.GetSecurityLevel();
436 EXPECT_EQ(SecurityLevel::S2, retSecurityLevel);
437
438 ConfigTestOpenCallback helper;
439 int errCode = E_ERROR;
440 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
441 EXPECT_NE(store, nullptr);
442 store = nullptr;
443 RdbHelper::DeleteRdbStore(dbPath);
444
445 config.SetSecurityLevel(SecurityLevel::LAST);
446 retSecurityLevel = config.GetSecurityLevel();
447 EXPECT_EQ(SecurityLevel::LAST, retSecurityLevel);
448 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
449 EXPECT_NE(store, nullptr);
450 }
451
452 /**
453 * @tc.name: RdbStoreConfig_014
454 * @tc.desc: test RdbStoreConfig interfaces: SetCreateNecessary/IsCreateNecessary
455 * @tc.type: FUNC
456 * @tc.require:
457 * @tc.author:
458 */
459 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_014, TestSize.Level1)
460 {
461 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
462 RdbStoreConfig config(dbPath);
463
464 bool createNecessary = true;
465 config.SetCreateNecessary(createNecessary);
466 bool retCreateNecessary = config.IsCreateNecessary();
467 EXPECT_EQ(createNecessary, retCreateNecessary);
468
469 ConfigTestOpenCallback helper;
470 int errCode = E_ERROR;
471 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
472 EXPECT_NE(store, nullptr);
473 store = nullptr;
474 RdbHelper::DeleteRdbStore(dbPath);
475
476 createNecessary = false;
477 config.SetCreateNecessary(createNecessary);
478 retCreateNecessary = config.IsCreateNecessary();
479 EXPECT_EQ(createNecessary, retCreateNecessary);
480
481 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
482 EXPECT_EQ(store, nullptr);
483 }
484
485 /**
486 * @tc.name: RdbStoreConfig_015
487 * @tc.desc: test RdbStoreConfig interfaces: SetReadOnly/IsReadOnly
488 * @tc.type: FUNC
489 * @tc.require:
490 * @tc.author:
491 */
492 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_015, TestSize.Level1)
493 {
494 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
495 RdbStoreConfig config(dbPath);
496
497 bool readOnly = true;
498 config.SetReadOnly(readOnly);
499 bool retReadOnly = config.IsReadOnly();
500 EXPECT_EQ(readOnly, retReadOnly);
501
502 ConfigTestOpenCallback helper;
503 int errCode = E_ERROR;
504 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
505 EXPECT_EQ(store, nullptr);
506 store = nullptr;
507 RdbHelper::DeleteRdbStore(dbPath);
508
509 readOnly = false;
510 config.SetReadOnly(readOnly);
511 retReadOnly = config.IsReadOnly();
512 EXPECT_EQ(readOnly, retReadOnly);
513
514 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
515 EXPECT_NE(store, nullptr);
516
517 readOnly = true;
518 config.SetReadOnly(readOnly);
519 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
520 EXPECT_NE(store, nullptr);
521 }
522
523 /**
524 * @tc.name: RdbStoreConfig_016
525 * @tc.desc: test RdbStoreConfig interfaces: SetStorageMode/GetStorageMode
526 * @tc.type: FUNC
527 * @tc.require:
528 * @tc.author:
529 */
530 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_016, TestSize.Level1)
531 {
532 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
533 RdbStoreConfig config(dbPath);
534
535 StorageMode storageMode = StorageMode::MODE_DISK;
536 config.SetStorageMode(storageMode);
537 StorageMode retStorageMode = config.GetStorageMode();
538 EXPECT_EQ(storageMode, retStorageMode);
539
540 ConfigTestOpenCallback helper;
541 int errCode = E_ERROR;
542 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
543 EXPECT_NE(store, nullptr);
544 store = nullptr;
545 RdbHelper::DeleteRdbStore(dbPath);
546
547 storageMode = StorageMode::MODE_MEMORY;
548 config.SetStorageMode(storageMode);
549 retStorageMode = config.GetStorageMode();
550 EXPECT_EQ(storageMode, retStorageMode);
551
552 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
553 EXPECT_NE(store, nullptr);
554 }
555
556 /**
557 * @tc.name: RdbStoreConfig_017
558 * @tc.desc: test RdbStoreConfig interfaces: SetDatabaseFileType/GetDatabaseFileType
559 * @tc.type: FUNC
560 * @tc.require:
561 * @tc.author:
562 */
563 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_017, TestSize.Level1)
564 {
565 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
566 RdbStoreConfig config(dbPath);
567
568 DatabaseFileType databaseFileType = DatabaseFileType::NORMAL;
569 config.SetDatabaseFileType(databaseFileType);
570 std::string retDatabaseFileType = config.GetDatabaseFileType();
571 EXPECT_EQ("db", retDatabaseFileType);
572
573 ConfigTestOpenCallback helper;
574 int errCode = E_ERROR;
575 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
576 EXPECT_NE(store, nullptr);
577 store = nullptr;
578 RdbHelper::DeleteRdbStore(dbPath);
579
580 databaseFileType = DatabaseFileType::BACKUP;
581 config.SetDatabaseFileType(databaseFileType);
582 retDatabaseFileType = config.GetDatabaseFileType();
583 EXPECT_EQ("backup", retDatabaseFileType);
584
585 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
586 EXPECT_NE(store, nullptr);
587 store = nullptr;
588 RdbHelper::DeleteRdbStore(dbPath);
589
590 databaseFileType = DatabaseFileType::CORRUPT;
591 config.SetDatabaseFileType(databaseFileType);
592 retDatabaseFileType = config.GetDatabaseFileType();
593 EXPECT_EQ("corrupt", retDatabaseFileType);
594
595 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
596 EXPECT_NE(store, nullptr);
597 }
598
599 /**
600 * @tc.name: RdbStoreConfig_018
601 * @tc.desc: test RdbStoreConfig interfaces: SetDistributedType/GetDistributedType
602 * @tc.type: FUNC
603 * @tc.require:
604 * @tc.author:
605 */
606 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_018, TestSize.Level1)
607 {
608 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
609 RdbStoreConfig config(dbPath);
610
611 DistributedType distributedType = DistributedType::RDB_DEVICE_COLLABORATION;
612 config.SetDistributedType(distributedType);
613 DistributedType retDistributedType = config.GetDistributedType();
614 EXPECT_EQ(distributedType, retDistributedType);
615
616 ConfigTestOpenCallback helper;
617 int errCode = E_ERROR;
618 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
619 EXPECT_NE(store, nullptr);
620 store = nullptr;
621 RdbHelper::DeleteRdbStore(dbPath);
622
623 distributedType = DistributedType::RDB_DISTRIBUTED_TYPE_MAX;
624 config.SetDistributedType(distributedType);
625 retDistributedType = config.GetDistributedType();
626 EXPECT_NE(distributedType, retDistributedType);
627
628 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 * @tc.require:
637 * @tc.author:
638 */
639 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_019, TestSize.Level1)
640 {
641 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
642 RdbStoreConfig config(dbPath);
643
644 std::string moduleName = "phone";
645 config.SetModuleName(moduleName);
646 std::string retModuleName = config.GetModuleName();
647 EXPECT_EQ(moduleName, retModuleName);
648
649 ConfigTestOpenCallback helper;
650 int errCode = E_ERROR;
651 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
652 EXPECT_NE(store, nullptr);
653 }
654
655 /**
656 * @tc.name: RdbStoreConfig_020
657 * @tc.desc: test RdbStoreConfig interfaces: SetModuleName/GetModuleName
658 * @tc.type: FUNC
659 * @tc.require:
660 * @tc.author:
661 */
662 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_020, TestSize.Level1)
663 {
664 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
665 RdbStoreConfig config(dbPath);
666
667 std::string serviceName = "com.ohos.config.test";
668 config.SetServiceName(serviceName);
669 std::string retServiceName = config.GetBundleName();
670 EXPECT_EQ(serviceName, retServiceName);
671
672 ConfigTestOpenCallback helper;
673 int errCode = E_ERROR;
674 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
675 EXPECT_NE(store, nullptr);
676 }
677
678 /**
679 * @tc.name: RdbStoreConfig_021
680 * @tc.desc: test RdbStoreConfig interfaces: GetSyncModeValue
681 * @tc.type: FUNC
682 * @tc.require:
683 * @tc.author:
684 */
685 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_021, TestSize.Level1)
686 {
687 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
688 RdbStoreConfig config(dbPath);
689
690 std::string syncMode = config.GetSyncModeValue(SyncMode::MODE_OFF);
691 EXPECT_EQ(syncMode, "MODE_OFF");
692 syncMode = OHOS::NativeRdb::RdbStoreConfig::GetSyncModeValue(SyncMode::MODE_NORMAL);
693 EXPECT_EQ(syncMode, "MODE_NORMAL");
694 syncMode = config.GetSyncModeValue(SyncMode::MODE_FULL);
695 EXPECT_EQ(syncMode, "MODE_FULL");
696 syncMode = config.GetSyncModeValue(SyncMode::MODE_EXTRA);
697 EXPECT_EQ(syncMode, "MODE_EXTRA");
698 }
699