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 = std::string("CREATE TABLE IF NOT EXISTS test ")
47 + 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
SetUpTestCase(void)61 void RdbStoreConfigTest::SetUpTestCase(void)
62 {
63 RdbHelper::DeleteRdbStore(RDB_TEST_PATH + "config_test.db");
64 }
65
TearDownTestCase(void)66 void RdbStoreConfigTest::TearDownTestCase(void)
67 {
68 RdbHelper::DeleteRdbStore(RDB_TEST_PATH + "config_test.db");
69 }
70
SetUp(void)71 void RdbStoreConfigTest::SetUp(void)
72 {
73 }
74
TearDown(void)75 void RdbStoreConfigTest::TearDown(void)
76 {
77 RdbHelper::DeleteRdbStore(RDB_TEST_PATH + "config_test.db");
78 RdbHelper::ClearCache();
79 }
80
81 /**
82 * @tc.name: RdbStoreConfig_001
83 * @tc.desc: test RdbStoreConfig
84 * @tc.type: FUNC
85 */
86 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_001, TestSize.Level1)
87 {
88 int errCode = E_OK;
89 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
90 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
91 ConfigTestOpenCallback helper;
92 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
93 EXPECT_NE(store, nullptr);
94 EXPECT_EQ(errCode, E_OK);
95
96 int64_t id;
97 ValuesBucket values;
98 values.PutInt("id", 1);
99 values.PutString("name", std::string("zhangsan"));
100 values.PutInt("age", 18);
101 values.PutDouble("salary", 100.5);
102 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
103 int ret = store->Insert(id, "test", values);
104 EXPECT_EQ(ret, E_OK);
105 EXPECT_EQ(1, id);
106
107 ret = access(dbPath.c_str(), F_OK);
108 EXPECT_EQ(ret, 0);
109
110 int currentVersion;
111 ret = store->GetVersion(currentVersion);
112 EXPECT_EQ(ret, E_OK);
113 EXPECT_EQ(1, currentVersion);
114
115 store = nullptr;
116 ret = RdbHelper::DeleteRdbStore(dbPath);
117 EXPECT_EQ(ret, E_OK);
118
119 StorageMode mode = config.GetStorageMode();
120 StorageMode targeMode = StorageMode::MODE_DISK;
121 EXPECT_EQ(mode, targeMode);
122 }
123
124 /**
125 * @tc.name: RdbStoreConfig_002
126 * @tc.desc: test RdbStoreConfig
127 * @tc.type: FUNC
128 */
129 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_002, TestSize.Level1)
130 {
131 int errCode = E_OK;
132 RdbStoreConfig config("", StorageMode::MODE_MEMORY);
133 ConfigTestOpenCallback helper;
134 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
135 EXPECT_NE(store, nullptr);
136 EXPECT_EQ(errCode, E_OK);
137
138 int64_t id;
139 ValuesBucket values;
140 values.PutInt("id", 1);
141 values.PutString("name", std::string("zhangsan"));
142 values.PutInt("age", 18);
143 values.PutDouble("salary", 100.5);
144 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
145 int ret = store->Insert(id, "test", values);
146 EXPECT_EQ(ret, E_OK);
147 EXPECT_EQ(1, id);
148
149 int currentVersion;
150 ret = store->GetVersion(currentVersion);
151 EXPECT_EQ(ret, E_OK);
152 EXPECT_EQ(1, currentVersion);
153
154 store->SetVersion(5);
155 ret = store->GetVersion(currentVersion);
156 EXPECT_EQ(ret, E_OK);
157 EXPECT_EQ(5, currentVersion);
158
159 store->SetVersion(2147483647);
160 ret = store->GetVersion(currentVersion);
161 EXPECT_EQ(ret, E_OK);
162 EXPECT_EQ(2147483647, currentVersion);
163
164 store->SetVersion(-2147483648);
165 ret = store->GetVersion(currentVersion);
166 EXPECT_EQ(ret, E_OK);
167 EXPECT_EQ(-2147483648, currentVersion);
168
169 std::string journalMode;
170 ret = store->ExecuteAndGetString(journalMode, "PRAGMA journal_mode");
171 EXPECT_EQ(ret, E_OK);
172 EXPECT_EQ(journalMode, "memory");
173
174 StorageMode mode = config.GetStorageMode();
175 StorageMode targeMode = StorageMode::MODE_MEMORY;
176 EXPECT_EQ(mode, targeMode);
177 }
178
179 /**
180 * @tc.name: RdbStoreConfig_003
181 * @tc.desc: test RdbStoreConfig
182 * @tc.type: FUNC
183 */
184 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_003, TestSize.Level1)
185 {
186 int errCode = E_OK;
187 RdbStoreConfig config("", StorageMode::MODE_DISK, false);
188 ConfigTestOpenCallback helper;
189 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
190 EXPECT_EQ(store, nullptr);
191 EXPECT_EQ(errCode, E_EMPTY_FILE_NAME);
192 }
193
194 /**
195 * @tc.name: RdbStoreConfig_004
196 * @tc.desc: test RdbStoreConfig
197 * @tc.type: FUNC
198 */
199 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_004, TestSize.Level1)
200 {
201 int errCode = E_OK;
202 const std::string dbPath = "config_test.db";
203 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
204 ConfigTestOpenCallback helper;
205 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
206 EXPECT_EQ(store, nullptr);
207 EXPECT_EQ(errCode, E_RELATIVE_PATH);
208 }
209
210 /**
211 * @tc.name: RdbStoreConfig_005
212 * @tc.desc: test RdbStoreConfig journalMode
213 * @tc.type: FUNC
214 */
215 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_005, TestSize.Level1)
216 {
217 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
218 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
219 std::string journalMode = config.GetJournalMode();
220 EXPECT_EQ(journalMode, "WAL");
221 ConfigTestOpenCallback helper;
222 int errCode = E_OK;
223 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
224 EXPECT_NE(store, nullptr);
225
226 std::string currentMode;
227 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
228 EXPECT_EQ(ret, E_OK);
229 EXPECT_EQ(currentMode, "wal");
230 }
231
232 /**
233 * @tc.name: RdbStoreConfig_006
234 * @tc.desc: test RdbStoreConfig journalMode
235 * @tc.type: FUNC
236 */
237 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_006, TestSize.Level1)
238 {
239 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
240 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
241 config.SetJournalMode(JournalMode::MODE_DELETE);
242 std::string journalMode = config.GetJournalMode();
243 EXPECT_EQ(journalMode, "DELETE");
244 ConfigTestOpenCallback helper;
245 int errCode = E_OK;
246 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
247 EXPECT_NE(store, nullptr);
248
249 std::string currentMode;
250 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
251 EXPECT_EQ(ret, E_OK);
252 EXPECT_EQ(currentMode, "delete");
253 }
254
255 /**
256 * @tc.name: RdbStoreConfig_007
257 * @tc.desc: test RdbStoreConfig journalMode
258 * @tc.type: FUNC
259 */
260 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_007, TestSize.Level1)
261 {
262 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
263 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
264 config.SetJournalMode(JournalMode::MODE_TRUNCATE);
265 std::string journalMode = config.GetJournalMode();
266 EXPECT_EQ(journalMode, "TRUNCATE");
267 ConfigTestOpenCallback helper;
268 int errCode = E_OK;
269 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
270 EXPECT_NE(store, nullptr);
271
272 std::string currentMode;
273 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
274 EXPECT_EQ(ret, E_OK);
275 EXPECT_EQ(currentMode, "truncate");
276 }
277
278 /**
279 * @tc.name: RdbStoreConfig_008
280 * @tc.desc: test RdbStoreConfig journalMode
281 * @tc.type: FUNC
282 */
283 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_008, TestSize.Level1)
284 {
285 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
286 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
287 config.SetJournalMode(JournalMode::MODE_PERSIST);
288 std::string journalMode = config.GetJournalMode();
289 EXPECT_EQ(journalMode, "PERSIST");
290 ConfigTestOpenCallback helper;
291 int errCode = E_OK;
292 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
293 EXPECT_NE(store, nullptr);
294
295 std::string currentMode;
296 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
297 EXPECT_EQ(ret, E_OK);
298 EXPECT_EQ(currentMode, "persist");
299 }
300
301 /**
302 * @tc.name: RdbStoreConfig_009
303 * @tc.desc: test RdbStoreConfig journalMode
304 * @tc.type: FUNC
305 */
306 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_009, TestSize.Level1)
307 {
308 LOG_INFO("RdbStoreConfig_007 start");
309 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
310 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
311 config.SetJournalMode(JournalMode::MODE_MEMORY);
312 std::string journalMode = config.GetJournalMode();
313 EXPECT_EQ(journalMode, "MEMORY");
314 ConfigTestOpenCallback helper;
315 int errCode = E_OK;
316 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
317 EXPECT_NE(store, nullptr);
318
319 std::string currentMode;
320 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
321 EXPECT_EQ(ret, E_OK);
322 EXPECT_EQ(currentMode, "memory");
323 }
324 /**
325 * @tc.name: RdbStoreConfig_010
326 * @tc.desc: test RdbStoreConfig journalMode
327 * @tc.type: FUNC
328 */
329 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_010, TestSize.Level1)
330 {
331 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
332 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
333 config.SetJournalMode(JournalMode::MODE_WAL);
334 std::string journalMode = config.GetJournalMode();
335 EXPECT_EQ(journalMode, "WAL");
336 ConfigTestOpenCallback helper;
337 int errCode = E_OK;
338 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
339 EXPECT_NE(store, nullptr);
340
341 std::string currentMode;
342 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
343 EXPECT_EQ(ret, E_OK);
344 EXPECT_EQ(currentMode, "wal");
345 }
346
347 /**
348 * @tc.name: RdbStoreConfig_011
349 * @tc.desc: test RdbStoreConfig journalMode
350 * @tc.type: FUNC
351 */
352 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_011, TestSize.Level1)
353 {
354 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
355 RdbStoreConfig config(dbPath, StorageMode::MODE_DISK, false);
356 config.SetJournalMode(JournalMode::MODE_OFF);
357 std::string journalMode = config.GetJournalMode();
358 EXPECT_EQ(journalMode, "OFF");
359 ConfigTestOpenCallback helper;
360 int errCode = E_OK;
361 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
362 EXPECT_NE(store, nullptr);
363
364 std::string currentMode;
365 int ret = store->ExecuteAndGetString(currentMode, "PRAGMA journal_mode");
366 EXPECT_EQ(ret, E_OK);
367 EXPECT_EQ(currentMode, "off");
368 }
369
370 /**
371 * @tc.name: RdbStoreConfig_012
372 * @tc.desc: test RdbStoreConfig SetReadPermission/GetReadPermission/SetWritePermission/GetWritePermission
373 * @tc.type: FUNC
374 */
375 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_012, TestSize.Level1)
376 {
377 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
378 RdbStoreConfig config(dbPath);
379
380 std::string readPermission = "readPermission";
381 config.SetReadPermission(readPermission);
382 std::string getReadPermission = config.GetReadPermission();
383 EXPECT_EQ(getReadPermission, readPermission);
384
385 std::string writePermission = "writePermission";
386 config.SetWritePermission(writePermission);
387 std::string getWritePermission = config.GetWritePermission();
388 EXPECT_EQ(getWritePermission, writePermission);
389
390 std::string uri = "uri";
391 config.SetUri(uri);
392 std::string getUri = config.GetUri();
393 EXPECT_EQ(getUri, uri);
394 }
395
396 /**
397 * @tc.name: RdbStoreConfig_013
398 * @tc.desc: test RdbStoreConfig interfaces: SetSecurityLevel/GetSecurityLevel
399 * @tc.type: FUNC
400 */
401 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_013, TestSize.Level1)
402 {
403 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
404 RdbStoreConfig config(dbPath);
405
406 config.SetSecurityLevel(SecurityLevel::S2);
407 SecurityLevel retSecurityLevel = config.GetSecurityLevel();
408 EXPECT_EQ(SecurityLevel::S2, retSecurityLevel);
409
410 ConfigTestOpenCallback helper;
411 int errCode = E_ERROR;
412 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
413 EXPECT_NE(store, nullptr);
414 store = nullptr;
415 RdbHelper::DeleteRdbStore(dbPath);
416
417 config.SetSecurityLevel(SecurityLevel::LAST);
418 retSecurityLevel = config.GetSecurityLevel();
419 EXPECT_EQ(SecurityLevel::LAST, retSecurityLevel);
420 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
421 EXPECT_NE(store, nullptr);
422 }
423
424 /**
425 * @tc.name: RdbStoreConfig_014
426 * @tc.desc: test RdbStoreConfig interfaces: SetCreateNecessary/IsCreateNecessary
427 * @tc.type: FUNC
428 */
429 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_014, TestSize.Level1)
430 {
431 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
432 RdbStoreConfig config(dbPath);
433
434 bool createNecessary = true;
435 config.SetCreateNecessary(createNecessary);
436 bool retCreateNecessary = config.IsCreateNecessary();
437 EXPECT_EQ(createNecessary, retCreateNecessary);
438
439 ConfigTestOpenCallback helper;
440 int errCode = E_ERROR;
441 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
442 EXPECT_NE(store, nullptr);
443 store = nullptr;
444 RdbHelper::DeleteRdbStore(dbPath);
445
446 createNecessary = false;
447 config.SetCreateNecessary(createNecessary);
448 retCreateNecessary = config.IsCreateNecessary();
449 EXPECT_EQ(createNecessary, retCreateNecessary);
450
451 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
452 EXPECT_EQ(store, nullptr);
453 }
454
455 /**
456 * @tc.name: RdbStoreConfig_015
457 * @tc.desc: test RdbStoreConfig interfaces: SetReadOnly/IsReadOnly
458 * @tc.type: FUNC
459 */
460 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_015, TestSize.Level1)
461 {
462 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
463 RdbStoreConfig config(dbPath);
464
465 bool readOnly = true;
466 config.SetReadOnly(readOnly);
467 bool retReadOnly = config.IsReadOnly();
468 EXPECT_EQ(readOnly, retReadOnly);
469
470 ConfigTestOpenCallback helper;
471 int errCode = E_ERROR;
472 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
473 EXPECT_EQ(store, nullptr);
474 store = nullptr;
475 RdbHelper::DeleteRdbStore(dbPath);
476
477 readOnly = false;
478 config.SetReadOnly(readOnly);
479 retReadOnly = config.IsReadOnly();
480 EXPECT_EQ(readOnly, retReadOnly);
481
482 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
483 EXPECT_NE(store, nullptr);
484
485 readOnly = true;
486 config.SetReadOnly(readOnly);
487 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
488 EXPECT_NE(store, nullptr);
489 }
490
491 /**
492 * @tc.name: RdbStoreConfig_016
493 * @tc.desc: test RdbStoreConfig interfaces: SetStorageMode/GetStorageMode
494 * @tc.type: FUNC
495 */
496 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_016, TestSize.Level1)
497 {
498 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
499 RdbStoreConfig config(dbPath);
500
501 StorageMode storageMode = StorageMode::MODE_DISK;
502 config.SetStorageMode(storageMode);
503 StorageMode retStorageMode = config.GetStorageMode();
504 EXPECT_EQ(storageMode, retStorageMode);
505
506 ConfigTestOpenCallback helper;
507 int errCode = E_ERROR;
508 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
509 EXPECT_NE(store, nullptr);
510 store = nullptr;
511 RdbHelper::DeleteRdbStore(dbPath);
512
513 storageMode = StorageMode::MODE_MEMORY;
514 config.SetStorageMode(storageMode);
515 retStorageMode = config.GetStorageMode();
516 EXPECT_EQ(storageMode, retStorageMode);
517
518 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
519 EXPECT_NE(store, nullptr);
520 }
521
522 /**
523 * @tc.name: RdbStoreConfig_017
524 * @tc.desc: test RdbStoreConfig interfaces: SetDatabaseFileType/GetDatabaseFileType
525 * @tc.type: FUNC
526 */
527 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_017, TestSize.Level1)
528 {
529 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
530 RdbStoreConfig config(dbPath);
531
532 DatabaseFileType databaseFileType = DatabaseFileType::NORMAL;
533 config.SetDatabaseFileType(databaseFileType);
534 std::string retDatabaseFileType = config.GetDatabaseFileType();
535 EXPECT_EQ("db", retDatabaseFileType);
536
537 ConfigTestOpenCallback helper;
538 int errCode = E_ERROR;
539 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
540 EXPECT_NE(store, nullptr);
541 store = nullptr;
542 RdbHelper::DeleteRdbStore(dbPath);
543
544 databaseFileType = DatabaseFileType::BACKUP;
545 config.SetDatabaseFileType(databaseFileType);
546 retDatabaseFileType = config.GetDatabaseFileType();
547 EXPECT_EQ("backup", retDatabaseFileType);
548
549 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
550 EXPECT_NE(store, nullptr);
551 store = nullptr;
552 RdbHelper::DeleteRdbStore(dbPath);
553
554 databaseFileType = DatabaseFileType::CORRUPT;
555 config.SetDatabaseFileType(databaseFileType);
556 retDatabaseFileType = config.GetDatabaseFileType();
557 EXPECT_EQ("corrupt", retDatabaseFileType);
558
559 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
560 EXPECT_NE(store, nullptr);
561 }
562
563 /**
564 * @tc.name: RdbStoreConfig_018
565 * @tc.desc: test RdbStoreConfig interfaces: SetDistributedType/GetDistributedType
566 * @tc.type: FUNC
567 */
568 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_018, TestSize.Level1)
569 {
570 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
571 RdbStoreConfig config(dbPath);
572
573 DistributedType distributedType = DistributedType::RDB_DEVICE_COLLABORATION;
574 config.SetDistributedType(distributedType);
575 DistributedType retDistributedType = config.GetDistributedType();
576 EXPECT_EQ(distributedType, retDistributedType);
577
578 ConfigTestOpenCallback helper;
579 int errCode = E_ERROR;
580 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
581 EXPECT_NE(store, nullptr);
582 store = nullptr;
583 RdbHelper::DeleteRdbStore(dbPath);
584
585 distributedType = DistributedType::RDB_DISTRIBUTED_TYPE_MAX;
586 config.SetDistributedType(distributedType);
587 retDistributedType = config.GetDistributedType();
588 EXPECT_NE(distributedType, retDistributedType);
589
590 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
591 EXPECT_NE(store, nullptr);
592 }
593
594 /**
595 * @tc.name: RdbStoreConfig_019
596 * @tc.desc: test RdbStoreConfig interfaces: SetModuleName/GetModuleName
597 * @tc.type: FUNC
598 */
599 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_019, TestSize.Level1)
600 {
601 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
602 RdbStoreConfig config(dbPath);
603
604 std::string moduleName = "phone";
605 config.SetModuleName(moduleName);
606 std::string retModuleName = config.GetModuleName();
607 EXPECT_EQ(moduleName, retModuleName);
608
609 ConfigTestOpenCallback helper;
610 int errCode = E_ERROR;
611 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
612 EXPECT_NE(store, nullptr);
613 }
614
615 /**
616 * @tc.name: RdbStoreConfig_020
617 * @tc.desc: test RdbStoreConfig interfaces: SetModuleName/GetModuleName
618 * @tc.type: FUNC
619 */
620 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_020, TestSize.Level1)
621 {
622 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
623 RdbStoreConfig config(dbPath);
624
625 std::string serviceName = "com.ohos.config.test";
626 config.SetServiceName(serviceName);
627 std::string retServiceName = config.GetBundleName();
628 EXPECT_EQ(serviceName, retServiceName);
629
630 ConfigTestOpenCallback helper;
631 int errCode = E_ERROR;
632 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
633 EXPECT_NE(store, nullptr);
634 }
635
636 /**
637 * @tc.name: RdbStoreConfig_021
638 * @tc.desc: test RdbStoreConfig interfaces: GetSyncModeValue
639 * @tc.type: FUNC
640 */
641 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_021, TestSize.Level1)
642 {
643 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
644 RdbStoreConfig config(dbPath);
645
646 std::string syncMode = config.GetSyncModeValue(SyncMode::MODE_OFF);
647 EXPECT_EQ(syncMode, "MODE_OFF");
648 syncMode = OHOS::NativeRdb::RdbStoreConfig::GetSyncModeValue(SyncMode::MODE_NORMAL);
649 EXPECT_EQ(syncMode, "MODE_NORMAL");
650 syncMode = config.GetSyncModeValue(SyncMode::MODE_FULL);
651 EXPECT_EQ(syncMode, "MODE_FULL");
652 syncMode = config.GetSyncModeValue(SyncMode::MODE_EXTRA);
653 EXPECT_EQ(syncMode, "MODE_EXTRA");
654 }
655
656 /**
657 * @tc.name: RdbStoreConfig_022
658 * @tc.desc: test RdbStoreConfig interfaces: SetAutoCheck/IsAutoCheck
659 * @tc.type: FUNC
660 */
661 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_022, TestSize.Level1)
662 {
663 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
664 RdbStoreConfig config(dbPath);
665
666 bool autoCheck = true;
667 config.SetAutoCheck(autoCheck);
668 bool retAutoCheck = config.IsAutoCheck();
669 EXPECT_EQ(autoCheck, retAutoCheck);
670
671 ConfigTestOpenCallback helper;
672 int errCode = E_ERROR;
673 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
674 EXPECT_NE(store, nullptr);
675 }
676
677 /**
678 * @tc.name: RdbStoreConfig_023
679 * @tc.desc: test RdbStoreConfig interfaces: SetJournalSize/GetJournalSize
680 * @tc.type: FUNC
681 */
682 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_023, TestSize.Level1)
683 {
684 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
685 RdbStoreConfig config(dbPath);
686
687 static constexpr int journalSize = 2 * 1024 * 1024;
688 config.SetJournalSize(journalSize);
689 int retJournalSize = config.GetJournalSize();
690 EXPECT_EQ(journalSize, retJournalSize);
691
692 ConfigTestOpenCallback helper;
693 int errCode = E_ERROR;
694 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
695 EXPECT_NE(store, nullptr);
696 store = nullptr;
697 RdbHelper::DeleteRdbStore(dbPath);
698
699 config.SetJournalSize(0);
700 retJournalSize = config.GetJournalSize();
701 EXPECT_EQ(0, retJournalSize);
702 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
703 EXPECT_NE(store, nullptr);
704 }
705
706 /**
707 * @tc.name: RdbStoreConfig_024
708 * @tc.desc: test RdbStoreConfig interfaces: SetJournalSize/GetJournalSize
709 * @tc.type: FUNC
710 */
711 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_024, TestSize.Level1)
712 {
713 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
714 RdbStoreConfig config(dbPath);
715
716 static constexpr int pageSize = 4 * 1024;
717 config.SetPageSize(pageSize);
718 int retPageSize = config.GetPageSize();
719 EXPECT_EQ(pageSize, retPageSize);
720
721 ConfigTestOpenCallback helper;
722 int errCode = E_ERROR;
723 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
724 EXPECT_NE(store, nullptr);
725 store = nullptr;
726 RdbHelper::DeleteRdbStore(dbPath);
727
728 config.SetPageSize(0);
729 retPageSize = config.GetPageSize();
730 EXPECT_EQ(0, retPageSize);
731 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
732 EXPECT_NE(store, nullptr);
733 }
734
735 /**
736 * @tc.name: RdbStoreConfig_025
737 * @tc.desc: test RdbStoreConfig interfaces: SetEncryptAlgo/GetEncryptAlgo
738 * @tc.type: FUNC
739 */
740 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_025, TestSize.Level1)
741 {
742 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
743 RdbStoreConfig config(dbPath);
744
745 std::string encryptAlgo = "sha256";
746 config.SetEncryptAlgo(encryptAlgo);
747 std::string retEncryptAlgo = config.GetEncryptAlgo();
748 EXPECT_EQ(encryptAlgo, retEncryptAlgo);
749
750 ConfigTestOpenCallback helper;
751 int errCode = E_ERROR;
752 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
753 EXPECT_NE(store, nullptr);
754 store = nullptr;
755 RdbHelper::DeleteRdbStore(dbPath);
756
757 config.SetEncryptAlgo("");
758 retEncryptAlgo = config.GetEncryptAlgo();
759 EXPECT_EQ("", retEncryptAlgo);
760 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
761 EXPECT_NE(store, nullptr);
762 }
763
764 /**
765 * @tc.name: RdbStoreConfig_026
766 * @tc.desc: test RdbStoreConfig interfaces: SetReadConSize/GetReadConSize
767 * @tc.type: FUNC
768 */
769 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_026, TestSize.Level1)
770 {
771 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
772 RdbStoreConfig config(dbPath);
773
774 static constexpr int readConSize = 4;
775 int retReadConSize = config.GetReadConSize();
776 EXPECT_EQ(readConSize, retReadConSize);
777
778 ConfigTestOpenCallback helper;
779 int errCode = E_ERROR;
780 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
781 EXPECT_NE(store, nullptr);
782 store = nullptr;
783 RdbHelper::DeleteRdbStore(dbPath);
784
785 config.SetReadConSize(20);
786 retReadConSize = config.GetReadConSize();
787 EXPECT_EQ(20, retReadConSize);
788 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
789 EXPECT_NE(store, nullptr);
790 store = nullptr;
791 RdbHelper::DeleteRdbStore(dbPath);
792
793 config.SetReadConSize(0);
794 retReadConSize = config.GetReadConSize();
795 EXPECT_EQ(0, retReadConSize);
796 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
797 EXPECT_NE(store, nullptr);
798 store = nullptr;
799 RdbHelper::DeleteRdbStore(dbPath);
800
801 config.SetReadConSize(1);
802 retReadConSize = config.GetReadConSize();
803 EXPECT_EQ(1, retReadConSize);
804 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
805 EXPECT_NE(store, nullptr);
806 store = nullptr;
807 RdbHelper::DeleteRdbStore(dbPath);
808
809 config.SetReadConSize(64);
810 retReadConSize = config.GetReadConSize();
811 EXPECT_EQ(64, retReadConSize);
812 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
813 EXPECT_NE(store, nullptr);
814 store = nullptr;
815 RdbHelper::DeleteRdbStore(dbPath);
816
817 config.SetReadConSize(65);
818 retReadConSize = config.GetReadConSize();
819 EXPECT_EQ(65, retReadConSize);
820 store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
821 EXPECT_EQ(store, nullptr);
822 }
823
824 /**
825 * @tc.name: RdbStoreConfig_027
826 * @tc.desc: test RdbStoreConfig interfaces: SetReadConSize/GetReadConSize
827 * @tc.type: FUNC
828 */
829 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_027, TestSize.Level1)
830 {
831 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
832 RdbStoreConfig config(dbPath);
833
834 static constexpr int readConSize = 10;
835 config.SetReadConSize(readConSize);
836 int retReadConSize = config.GetReadConSize();
837 EXPECT_EQ(readConSize, retReadConSize);
838
839 ConfigTestOpenCallback helper;
840 int errCode = E_ERROR;
841 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
842 EXPECT_NE(store, nullptr);
843 EXPECT_EQ(errCode, E_OK);
844
845 int64_t id;
846 ValuesBucket values;
847 values.PutInt("id", 1);
848 values.PutString("name", std::string("zhangsan"));
849 values.PutInt("age", 18);
850 values.PutDouble("salary", 100.5);
851 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
852 int ret = store->Insert(id, "test", values);
853 EXPECT_EQ(ret, E_OK);
854 EXPECT_EQ(1, id);
855
856 std::vector<std::shared_ptr<ResultSet>> resultSets;
857 for (int i = 0; i < readConSize; ++i) {
858 auto resultSet = store->QueryByStep("SELECT * FROM test");
859 EXPECT_NE(resultSet, nullptr);
860 EXPECT_EQ(E_OK, resultSet->GoToFirstRow());
861 resultSets.push_back(resultSet);
862 }
863 for (const auto &resultSet: resultSets) {
864 EXPECT_EQ(E_OK, resultSet->Close());
865 }
866 }
867
868 /**
869 * @tc.name: RdbStoreConfig_028
870 * @tc.desc: test RdbStoreConfig interfaces: SetDataGroupId/GetDataGroupId
871 * @tc.type: FUNC
872 */
873 HWTEST_F(RdbStoreConfigTest, RdbStoreConfig_028, TestSize.Level1)
874 {
875 const std::string dbPath = RDB_TEST_PATH + "config_test.db";
876 RdbStoreConfig config(dbPath);
877
878 std::string dataGroupId = "123456";
879 config.SetDataGroupId(dataGroupId);
880 EXPECT_EQ(dataGroupId, config.GetDataGroupId());
881 }