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 #ifndef OMIT_MULTI_VER
16 #include <gtest/gtest.h>
17 #include <ctime>
18 #include <cmath>
19 #include <thread>
20 #include <condition_variable>
21 #include <mutex>
22 #include <string>
23 
24 #include "delegate_kv_mgr_callback.h"
25 #include "distributeddb_data_generator.h"
26 #include "distributed_test_tools.h"
27 #include "kv_store_delegate.h"
28 #include "kv_store_delegate_manager.h"
29 #include "distributed_test_sysinfo.h"
30 
31 using namespace std;
32 using namespace testing;
33 #if defined TESTCASES_USING_GTEST_EXT
34 using namespace testing::ext;
35 #endif
36 using namespace DistributedDB;
37 using namespace DistributedDBDataGenerator;
38 
39 namespace DistributeddbKvCreate {
40 const int OPER_CNT = 4;
41 DistributedDB::CipherPassword g_passwd1;
42 DistributedDB::CipherPassword g_passwd2;
43 class DistributeddbKvCreateTest : public testing::Test {
44 public:
45     static void SetUpTestCase(void);
46     static void TearDownTestCase(void);
47     void SetUp();
48     void TearDown();
49 };
50 
SetUpTestCase(void)51 void DistributeddbKvCreateTest::SetUpTestCase(void)
52 {
53     (void)g_passwd1.SetValue(PASSWD_VECTOR_1.data(), PASSWD_VECTOR_1.size());
54     (void)g_passwd2.SetValue(PASSWD_VECTOR_2.data(), PASSWD_VECTOR_2.size());
55 }
56 
TearDownTestCase(void)57 void DistributeddbKvCreateTest::TearDownTestCase(void)
58 {
59 }
60 
SetUp(void)61 void DistributeddbKvCreateTest::SetUp(void)
62 {
63     UnitTest *test = UnitTest::GetInstance();
64     ASSERT_NE(test, nullptr);
65     const TestInfo *testinfo = test->current_test_info();
66     ASSERT_NE(testinfo, nullptr);
67     string testCaseName = string(testinfo->name());
68     MST_LOG("[SetUp] test case %s is start to run", testCaseName.c_str());
69 }
70 
TearDown(void)71 void DistributeddbKvCreateTest::TearDown(void)
72 {
73 }
74 
75 /*
76  * @tc.name: Open 001
77  * @tc.desc: Verify that the kv db was created successfully.
78  * @tc.type: FUNC
79  * @tc.require: SR000CQS3O
80  * @tc.author: luqianfu
81  */
82 HWTEST_F(DistributeddbKvCreateTest, Open001, TestSize.Level1)
83 {
84     KvStoreDelegateManager *manager1 = nullptr;
85     KvStoreDelegateManager *manager2 = nullptr;
86     KvStoreDelegateManager *manager3 = nullptr;
87     KvStoreDelegateManager *manager4 = nullptr;
88 
89     /**
90      * @tc.steps: step1. create kv db with params storeId1, appId1, userId1.
91      * @tc.expected: step1. the kv db was created successfully.
92      */
93     KvStoreDelegate *result = nullptr;
94     result = DistributedTestTools::GetDelegateSuccess(manager1, g_kvdbParameter1, g_kvOption);
95     ASSERT_TRUE(manager1 != nullptr && result != nullptr);
96     EXPECT_TRUE(manager1->CloseKvStore(result) == OK);
97     result = nullptr;
98     /**
99      * @tc.steps: step2. create kv db with params storeId2, appId1, userId1.
100      * @tc.expected: step2. the kv db was created successfully.
101      */
102     result = DistributedTestTools::GetDelegateSuccess(manager2, g_kvdbParameter2_1_1, g_kvOption);
103     ASSERT_TRUE(manager2 != nullptr && result != nullptr);
104     EXPECT_TRUE(manager2->CloseKvStore(result) == OK);
105     result = nullptr;
106     /**
107      * @tc.steps: step3. create kv db with params storeId1, appId2, userId1.
108      * @tc.expected: step3. the kv db was created successfully.
109      */
110     result = DistributedTestTools::GetDelegateSuccess(manager3, g_kvdbParameter1_2_1, g_kvOption);
111     ASSERT_TRUE(manager3 != nullptr && result != nullptr);
112     EXPECT_TRUE(manager3->CloseKvStore(result) == OK);
113     result = nullptr;
114     /**
115      * @tc.steps: step4. create kv db with params storeId1, appId1, userId2.
116      * @tc.expected: step4. the kv db was created successfully.
117      */
118     result = DistributedTestTools::GetDelegateSuccess(manager4, g_kvdbParameter1_1_2, g_kvOption);
119     ASSERT_TRUE(manager4 != nullptr && result != nullptr);
120     EXPECT_EQ(manager4->CloseKvStore(result), OK);
121     result = nullptr;
122 
123     EXPECT_EQ(manager1->DeleteKvStore(STORE_ID_1), OK);
124     delete manager1;
125     manager1 = nullptr;
126     EXPECT_EQ(manager2->DeleteKvStore(STORE_ID_2), OK);
127     delete manager2;
128     manager2 = nullptr;
129     EXPECT_EQ(manager3->DeleteKvStore(STORE_ID_1), OK);
130     delete manager3;
131     manager3 = nullptr;
132     EXPECT_EQ(manager4->DeleteKvStore(STORE_ID_1), OK);
133     delete manager4;
134     manager4 = nullptr;
135 }
136 
137 /*
138  * @tc.name: Open 002
139  * @tc.desc: Verify that the kv db can be reopened successfully
140  * @tc.type: FUNC
141  * @tc.require: SR000CQS3O
142  * @tc.author: luqianfu
143  */
144 HWTEST_F(DistributeddbKvCreateTest, Open002, TestSize.Level1)
145 {
146     KvStoreDelegate *result = nullptr;
147     KvStoreDelegateManager *manager = nullptr;
148     /**
149      * @tc.steps: step1. create kv db.
150      * @tc.expected: step1. the kv db was created successfully.
151      */
152     KvOption option = g_kvOption;
153     option.localOnly = IS_LOCAL_ONLY;
154     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
155     ASSERT_TRUE(manager != nullptr && result != nullptr);
156     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
157     delete manager;
158     manager = nullptr;
159     /**
160      * @tc.steps: step2. reopen kv db.
161      * @tc.expected: step2. the kv db was reopened successfully.
162      */
163     option.createIfNecessary = IS_NOT_NEED_CREATE;
164     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
165     ASSERT_TRUE(manager != nullptr && result != nullptr);
166 
167     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
168     result = nullptr;
169     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
170     delete manager;
171     manager = nullptr;
172 }
173 
174 /*
175  * @tc.name: Open 003
176  * @tc.desc: Verify that can not reopen an absent db.
177  * @tc.type: FUNC
178  * @tc.require: SR000CQS3O
179  * @tc.author: luqianfu
180  */
181 HWTEST_F(DistributeddbKvCreateTest, Open003, TestSize.Level1)
182 {
183     /**
184      * @tc.steps: step1. delete kv db if exist.
185      * @tc.expected: step1. Construct that no database exist.
186      */
187     KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
188     ASSERT_NE(manager, nullptr);
189     SetDir(DIRECTOR);
190     DBStatus status = manager->SetKvStoreConfig(KV_CONFIG);
191     EXPECT_EQ(status, DBStatus::OK);
192     status = manager->DeleteKvStore(STORE_ID_1);
193     EXPECT_EQ(status, DBStatus::NOT_FOUND);
194     delete manager;
195     manager = nullptr;
196 
197     KvStoreDelegate *delegate = nullptr;
198     /**
199      * @tc.steps: step2. reopen an absent db.
200      * @tc.expected: step2. reopen failed and return error.
201      */
202     KvOption option = g_kvOption;
203     option.createIfNecessary = IS_NOT_NEED_CREATE;
204     option.localOnly = IS_LOCAL_ONLY;
205     status = DistributedTestTools::GetDelegateNotGood(manager, delegate, STORE_ID_1, APP_ID_1, USER_ID_1, option);
206     ASSERT_NE(status, DBStatus::OK);
207     EXPECT_EQ(delegate, nullptr);
208     EXPECT_EQ(manager->CloseKvStore(delegate), INVALID_ARGS);
209 
210     delete manager;
211     manager = nullptr;
212 }
213 
214 /*
215  * @tc.name: Open 004
216  * @tc.desc: Verify that transferring param IS_NOT_NEED_CREATE can not create kv db.
217  * @tc.type: FUNC
218  * @tc.require: SR000BUH3J
219  * @tc.author: luqianfu
220  */
221 HWTEST_F(DistributeddbKvCreateTest, Open004, TestSize.Level1)
222 {
223     KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_2);
224     ASSERT_NE(manager, nullptr);
225     SetDir(DIRECTOR);
226     EXPECT_EQ(manager->SetKvStoreConfig(KV_CONFIG), DBStatus::OK);
227     EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), DBStatus::NOT_FOUND);
228 
229     KvStoreDelegateManager *manager1 = nullptr;
230     KvStoreDelegateManager *manager2 = nullptr;
231     /**
232      * @tc.steps: step1. create kv db with param IS_NOT_NEED_CREATE.
233      * @tc.expected: step1. create kv db and close it failed.
234      */
235     KvOption option = g_kvOption;
236     option.createIfNecessary = IS_NOT_NEED_CREATE;
237     KvStoreDelegate *result1 = DistributedTestTools::GetDelegateSuccess(manager1, g_kvdbParameter1_1_2, option);
238     EXPECT_TRUE(manager1 == nullptr && result1 == nullptr);
239     EXPECT_TRUE(manager->CloseKvStore(result1) != OK);
240     delete manager;
241     manager = nullptr;
242 
243     /**
244      * @tc.steps: step2. create kv db with param IS_NEED_CREATE.
245      * @tc.expected: step2. create kv db and close it successfully.
246      */
247     KvStoreDelegate *result2 = DistributedTestTools::GetDelegateSuccess(manager2, g_kvdbParameter1_1_2,
248         g_kvOption);
249     ASSERT_TRUE(manager2 != nullptr && result2 != nullptr);
250     EXPECT_TRUE(manager2->CloseKvStore(result2) == OK);
251     result2 = nullptr;
252     EXPECT_TRUE(manager2->DeleteKvStore(STORE_ID_1) == OK);
253     delete manager2;
254     manager2 = nullptr;
255 }
256 
257 /*
258  * @tc.name: Open 005
259  * @tc.desc: Verify that can not create or open kv db with exceptional params.
260  * @tc.type: EXCEPTION
261  * @tc.require: SR000BUH3J
262  * @tc.author: luqianfu
263  */
264 HWTEST_F(DistributeddbKvCreateTest, Open005, TestSize.Level1)
265 {
266     KvStoreDelegateManager *manager1 = nullptr;
267     KvStoreDelegateManager *manager2 = nullptr;
268     KvStoreDelegateManager *manager3 = nullptr;
269     KvStoreDelegateManager *manager4 = nullptr;
270     KvStoreDelegate *delegate1 = nullptr;
271     KvStoreDelegate *delegate2 = nullptr;
272     KvStoreDelegate *delegate3 = nullptr;
273     KvStoreDelegate *delegate4 = nullptr;
274 
275     /**
276      * @tc.steps: step1. create kv db with param storeId is null.
277      * @tc.expected: step1. create kv db failed.
278      */
279     KvOption option1 = g_kvOption;
280     option1.createIfNecessary = IS_NEED_CREATE;
281     option1.localOnly = IS_LOCAL_ONLY;
282     DBStatus status = DistributedTestTools::GetDelegateNotGood(manager1, delegate1, "", APP_ID_1, USER_ID_1, option1);
283     ASSERT_EQ(status, DBStatus::INVALID_ARGS);
284     EXPECT_TRUE(delegate1 == nullptr);
285     EXPECT_TRUE(manager1->CloseKvStore(delegate1) == INVALID_ARGS);
286 
287     /**
288      * @tc.steps: step2. create kv db with param appId is null.
289      * @tc.expected: step2. create kv db failed.
290      */
291     KvOption option2 = g_kvOption;
292     option2.createIfNecessary = IS_NEED_CREATE;
293     option2.localOnly = IS_LOCAL_ONLY;
294     status = DistributedTestTools::GetDelegateNotGood(manager2, delegate2, STORE_ID_1, "", USER_ID_1, option2);
295     ASSERT_EQ(status, DBStatus::INVALID_ARGS);
296     EXPECT_TRUE(delegate2 == nullptr);
297     EXPECT_TRUE(manager2->CloseKvStore(delegate2) == INVALID_ARGS);
298 
299     /**
300      * @tc.steps: step3. create kv db with param userId is null.
301      * @tc.expected: step3. create kv db failed.
302      */
303     KvOption option3 = g_kvOption;
304     option3.createIfNecessary = IS_NEED_CREATE;
305     option3.localOnly = IS_LOCAL_ONLY;
306     status = DistributedTestTools::GetDelegateNotGood(manager3, delegate3, STORE_ID_1, APP_ID_1, "", option3);
307     ASSERT_EQ(status, DBStatus::INVALID_ARGS);
308     EXPECT_TRUE(delegate3 == nullptr);
309     EXPECT_TRUE(manager3->CloseKvStore(delegate3) == INVALID_ARGS);
310 
311     /**
312      * @tc.steps: step3. create kv db with param userId is null.
313      * @tc.expected: step3. create kv db failed.
314      */
315     KvOption option4 = g_kvOption;
316     option4.createIfNecessary = IS_NOT_NEED_CREATE;
317     option4.localOnly = IS_LOCAL_ONLY;
318     status = DistributedTestTools::GetDelegateNotGood(manager4, delegate4, STORE_ID_1, APP_ID_1, USER_ID_1, option4);
319     ASSERT_NE(status, DBStatus::OK);
320     EXPECT_TRUE(delegate4 == nullptr);
321     EXPECT_TRUE(manager4->CloseKvStore(delegate4) == INVALID_ARGS);
322 
323     delete manager1;
324     manager1 = nullptr;
325     delete manager2;
326     manager2 = nullptr;
327     delete manager3;
328     manager3 = nullptr;
329     delete manager4;
330     manager4 = nullptr;
331 }
332 
333 /*
334  * @tc.name: Close 001
335  * @tc.desc: Verify that can close kv db successfully.
336  * @tc.type: FUNC
337  * @tc.require: SR000BUH3J
338  * @tc.author: luqianfu
339  */
340 HWTEST_F(DistributeddbKvCreateTest, Close001, TestSize.Level1)
341 {
342     KvStoreDelegate *result = nullptr;
343     KvStoreDelegateManager *manager = nullptr;
344 
345     /**
346      * @tc.steps: step1. create and open kv db.
347      * @tc.expected: step1. create and open kv db successfully.
348      */
349     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
350     ASSERT_TRUE(manager != nullptr && result != nullptr);
351 
352     /**
353      * @tc.steps: step2. close kv db that exist.
354      * @tc.expected: step2. close kv db successfully.
355      */
356     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
357     result = nullptr;
358     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
359     delete manager;
360     manager = nullptr;
361 }
362 
363 /*
364  * @tc.name: Close 002
365  * @tc.desc: Verify that can not close absent db successfully.
366  * @tc.type: FUNC
367  * @tc.require: SR000BUH3J
368  * @tc.author: luqianfu
369  */
370 HWTEST_F(DistributeddbKvCreateTest, Close002, TestSize.Level1)
371 {
372     KvStoreDelegate *result = nullptr;
373     KvStoreDelegateManager *manager = nullptr;
374 
375     /**
376      * @tc.steps: step1. create and delete kv db.
377      * @tc.expected: step1. Construct that no database exist.
378      */
379     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
380     ASSERT_TRUE(manager != nullptr && result != nullptr);
381     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
382     result = nullptr;
383 
384     /**
385      * @tc.steps: step2. close nonexistent db.
386      * @tc.expected: step2. close db failed.
387      */
388     EXPECT_EQ(manager->CloseKvStore(result), INVALID_ARGS);
389 
390     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
391     delete manager;
392     manager = nullptr;
393 }
394 
395 /*
396  * @tc.name: Delete 001
397  * @tc.desc: Verify that can delete db successfully.
398  * @tc.type: FUNC
399  * @tc.require: SR000BUH3J
400  * @tc.author: luqianfu
401  */
402 HWTEST_F(DistributeddbKvCreateTest, Delete001, TestSize.Level1)
403 {
404     KvStoreDelegate *result = nullptr;
405     KvStoreDelegateManager *manager = nullptr;
406 
407     /**
408      * @tc.steps: step1. create and close kv db.
409      * @tc.expected: step1. Construct that database exist.
410      */
411     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
412     ASSERT_TRUE(manager != nullptr && result != nullptr);
413     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
414     result = nullptr;
415     /**
416      * @tc.steps: step2. delete db.
417      * @tc.expected: step2. delete db successfully.
418      */
419     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
420 
421     delete manager;
422     manager = nullptr;
423 }
424 
425 /*
426  * @tc.name: Delete 002
427  * @tc.desc: Verify that can not delete absent db.
428  * @tc.type: FUNC
429  * @tc.require: SR000BUH3J
430  * @tc.author: luqianfu
431  */
432 HWTEST_F(DistributeddbKvCreateTest, Delete002, TestSize.Level1)
433 {
434     KvStoreDelegate *result = nullptr;
435     KvStoreDelegateManager *manager = nullptr;
436 
437     /**
438      * @tc.steps: step1. create and delete kv db.
439      * @tc.expected: step1. Construct that no database exist.
440      */
441     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
442     ASSERT_TRUE(manager != nullptr && result != nullptr);
443     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
444     result = nullptr;
445     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
446 
447     /**
448      * @tc.steps: step2. delete absent db.
449      * @tc.expected: step2. delete absent db failed.
450      */
451     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == NOT_FOUND);
452 
453     delete manager;
454     manager = nullptr;
455 }
456 
457 /*
458  * @tc.name: Config 001
459  * @tc.desc: Verify that can set global config of db.
460  * @tc.type: FUNC
461  * @tc.require: SR000BUH3J
462  * @tc.author: luqianfu
463  */
464 HWTEST_F(DistributeddbKvCreateTest, Config001, TestSize.Level1)
465 {
466     KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
467     ASSERT_NE(manager, nullptr);
468     /**
469      * @tc.steps: step1. set rightly exist global config of db.
470      * @tc.expected: step1. set successfully.
471      */
472     SetDir(DIRECTOR);
473     KvStoreConfig config;
474     config.dataDir = DIRECTOR;
475     EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::OK);
476     /**
477      * @tc.steps: step2. set exceptionally not exist global config of db.
478      * @tc.expected: step2. set failed.
479      */
480     config.dataDir = "/dataDED/";
481     EXPECT_EQ(manager->SetKvStoreConfig(config), INVALID_ARGS);
482     delete manager;
483     manager = nullptr;
484 }
485 
486 /*
487  * @tc.name: Config 002
488  * @tc.desc: Verify that can get the set storeid and check it.
489  * @tc.type: FUNC
490  * @tc.require: SR000BUH3J
491  * @tc.author: luqianfu
492  */
493 HWTEST_F(DistributeddbKvCreateTest, Config002, TestSize.Level1)
494 {
495     KvStoreDelegate *result = nullptr;
496     KvStoreDelegateManager *manager = nullptr;
497     /**
498      * @tc.steps: step1. create kv db with STORE_ID_1.
499      * @tc.expected: step1. create db successfully.
500      */
501     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
502     ASSERT_TRUE(manager != nullptr && result != nullptr);
503 
504     /**
505      * @tc.steps: step2. get the set storeid of db.
506      * @tc.expected: step2. get the set storeid successfully and it equals STORE_ID_1.
507      */
508     string storeid = result->GetStoreId();
509     ASSERT_STREQ(STORE_ID_1.c_str(), storeid.c_str());
510 
511     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
512     result = nullptr;
513     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
514     delete manager;
515     manager = nullptr;
516 }
517 
518 /*
519  * @tc.name: Performance 001
520  * @tc.desc: calculate the time of creating db.
521  * @tc.type: Performance
522  * @tc.require: SR000BUH3J
523  * @tc.author: luqianfu
524  */
525 HWTEST_F(DistributeddbKvCreateTest, Performance001, TestSize.Level2)
526 {
527     std::chrono::steady_clock::time_point tick, tock;
528     /**
529      * @tc.steps: step1. get the time1 and then create kv db.
530      * @tc.expected: step1. create kv db successfully.
531      */
532     SetDir(DIRECTOR);
533     DelegateKvMgrCallback delegateKvMgrCallback;
534     function<void(DBStatus, KvStoreDelegate*)> function
535         = bind(&DelegateKvMgrCallback::Callback, &delegateKvMgrCallback, std::placeholders::_1, std::placeholders::_2);
536 
537     KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
538     ASSERT_NE(manager, nullptr);
539     EXPECT_EQ(manager->SetKvStoreConfig(KV_CONFIG), DBStatus::OK);
540     KvStoreDelegate::Option option = DistributedTestTools::TransferKvOptionType(g_kvOption);
541 
542     tick = std::chrono::steady_clock::now();
543     manager->GetKvStore(STORE_ID_1, option, function);
544     tock = std::chrono::steady_clock::now();
545 
546     KvStoreDelegate* delegate = const_cast<KvStoreDelegate*>(delegateKvMgrCallback.GetKvStore());
547     EXPECT_NE(delegate, nullptr);
548     /**
549      * @tc.steps: step2. get the time2 after creating kv db.
550      * @tc.expected: step2. time2-time1<100s.
551      */
552     std::chrono::duration<uint64_t, std::milli> dur;
553     dur = std::chrono::duration_cast<std::chrono::milliseconds>(tock - tick);
554     double duration = static_cast<double>(dur.count());
555     MST_LOG("the time used for create DB is %f ms", duration);
556 
557     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
558     delegate = nullptr;
559     EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
560     delete manager;
561     manager = nullptr;
562 }
563 
564 /*
565  * @tc.name: Performance 002
566  * @tc.desc: check the system or cpu storage and power when creating db.
567  * @tc.type: Performance
568  * @tc.require: SR000BUH3J
569  * @tc.author: luqianfu
570  */
571 HWTEST_F(DistributeddbKvCreateTest, Performance002, TestSize.Level2)
572 {
573     /**
574      * @tc.steps: step1. get the system info before creating db.
575      * @tc.expected: step1. the system or cpu storage and power is normal.
576      */
577     DistributedTestSysInfo si;
578     MST_LOG("System info before opening db");
579     si.GetSysMemOccpy(FIRST);
580     si.GetSysCpuUsage(FIRST, DEFAULT_INTEVAL);
581     si.GetSysCurrentPower(FIRST, DEFAULT_COUNT, DEFAULT_INTEVAL);
582 
583     /**
584      * @tc.steps: step2. construct the params for interface and create db
585      * @tc.expected: step2. create db successfully.
586      */
587     KvStoreDelegate *result = nullptr;
588     KvStoreDelegateManager *manager = nullptr;
589     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
590     ASSERT_TRUE(manager != nullptr && result != nullptr);
591 
592     /**
593      * @tc.steps: step3. get the system info after creating db.
594      * @tc.expected: step3. the system or cpu storage and power is normal.
595      */
596     MST_LOG("System info after opening db");
597     si.GetSysMemOccpy(SECOND);
598     si.GetSysCpuUsage(SECOND, DEFAULT_INTEVAL);
599     si.GetSysCurrentPower(SECOND, DEFAULT_COUNT, DEFAULT_INTEVAL);
600 
601     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
602     result = nullptr;
603     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == DBStatus::OK);
604     delete manager;
605     manager = nullptr;
606 }
607 
608 /*
609  * @tc.name: Performance 003
610  * @tc.desc: calculate the time of reopening db.
611  * @tc.type: Performance
612  * @tc.require: SR000BUH3J
613  * @tc.author: luqianfu
614  */
615 HWTEST_F(DistributeddbKvCreateTest, Performance003, TestSize.Level2)
616 {
617     KvStoreDelegate *delegate = nullptr;
618     KvStoreDelegateManager *manager = nullptr;
619     /**
620      * @tc.steps: step1. create and close kv db.
621      * @tc.expected: step1. Construct that database exist.
622      */
623     KvOption option = g_kvOption;
624     option.localOnly = IS_LOCAL_ONLY;
625     delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
626     ASSERT_TRUE(manager != nullptr && delegate != nullptr);
627     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
628     delegate = nullptr;
629 
630     DelegateKvMgrCallback delegateKvMgrCallback;
631     function<void(DBStatus, KvStoreDelegate*)> function
632         = bind(&DelegateKvMgrCallback::Callback, &delegateKvMgrCallback, std::placeholders::_1, std::placeholders::_2);
633     std::chrono::steady_clock::time_point tick, tock;
634     option.createIfNecessary = IS_NOT_NEED_CREATE;
635     /**
636      * @tc.steps: step2. get the tick and tock value of the system before and after reopen the db.
637      * @tc.expected: step2. the system time of tick and tock obtained successfully.
638      */
639     KvStoreDelegate::Option optionUsedForGetStore = DistributedTestTools::TransferKvOptionType(option);
640     tick = std::chrono::steady_clock::now();
641     manager->GetKvStore(STORE_ID_1, optionUsedForGetStore, function);
642     tock = std::chrono::steady_clock::now();
643 
644     /**
645      * @tc.steps: step3. tock - tick and translate it to milliseconds.
646      * @tc.expected: step3. tock - tick < 150ms.
647      */
648     std::chrono::duration<uint64_t, std::milli> dur;
649     dur = std::chrono::duration_cast<std::chrono::milliseconds>(tock - tick);
650     double duration = static_cast<double>(dur.count());
651     MST_LOG("the time used for reopen DB is %f ms", duration);
652 
653     delegate = const_cast<KvStoreDelegate*>(delegateKvMgrCallback.GetKvStore());
654     EXPECT_NE(delegate, nullptr);
655 
656     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
657     delegate = nullptr;
658     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == DBStatus::OK);
659     delete manager;
660     manager = nullptr;
661 }
662 
663 /*
664  * @tc.name: Performance 004
665  * @tc.desc: check the system or cpu storage and power when reopening db.
666  * @tc.type: System overhead
667  * @tc.require: SR000BUH3J
668  * @tc.author: luqianfu
669  */
670 HWTEST_F(DistributeddbKvCreateTest, Performance004, TestSize.Level3)
671 {
672     KvStoreDelegate *delegate = nullptr;
673     KvStoreDelegateManager *manager = nullptr;
674     /**
675      * @tc.steps: step1. create and close kv db.
676      * @tc.expected: step1. Construct that database exist.
677      */
678     KvOption option04 = g_kvOption;
679     option04.localOnly = IS_LOCAL_ONLY;
680     delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option04);
681     ASSERT_TRUE(manager != nullptr && delegate != nullptr);
682     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
683     delegate = nullptr;
684     delete manager;
685     manager = nullptr;
686 
687     /**
688      * @tc.steps: step2. get the system info before reopening db and then reopen db.
689      * @tc.expected: step2. the system or cpu storage and power is normal and reopen db successful .
690      */
691     MST_LOG("System info before reopening db");
692     DistributedTestSysInfo sysInfo04;
693     sysInfo04.GetSysMemOccpy(FIRST);
694     sysInfo04.GetSysCpuUsage(FIRST, DEFAULT_INTEVAL);
695     sysInfo04.GetSysCurrentPower(FIRST, DEFAULT_COUNT, DEFAULT_INTEVAL);
696     option04.createIfNecessary = IS_NOT_NEED_CREATE;
697     delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option04);
698     ASSERT_TRUE(manager != nullptr && delegate != nullptr);
699 
700     /**
701      * @tc.steps: step3. get the system info after reopening db.
702      * @tc.expected: step3. the system or cpu storage and power is normal and reopen db successful.
703      */
704     MST_LOG("System info after reopening db");
705     sysInfo04.GetSysMemOccpy(SECOND);
706     sysInfo04.GetSysCpuUsage(SECOND, DEFAULT_INTEVAL);
707     sysInfo04.GetSysCurrentPower(SECOND, DEFAULT_COUNT, DEFAULT_INTEVAL);
708 
709     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
710     delegate = nullptr;
711     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == DBStatus::OK);
712     delete manager;
713     manager = nullptr;
714 }
715 
716 /*
717  * @tc.name: Performance 005
718  * @tc.desc: check the system storage when reopening by reopening db.
719  * @tc.type: System overhead
720  * @tc.require: SR000BUH3J
721  * @tc.author: luqianfu
722  */
723 HWTEST_F(DistributeddbKvCreateTest, Performance005, TestSize.Level3)
724 {
725     KvStoreDelegate *delegate = nullptr;
726     KvStoreDelegateManager *manager = nullptr;
727     /**
728      * @tc.steps: step1. create and close kv db.
729      * @tc.expected: step1. Construct that database exist.
730      */
731     KvOption option05 = g_kvOption;
732     option05.localOnly = IS_LOCAL_ONLY;
733     delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option05);
734     ASSERT_TRUE(manager != nullptr && delegate != nullptr);
735     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
736     delegate = nullptr;
737     delete manager;
738     manager = nullptr;
739 
740     /**
741      * @tc.steps: step2. reopen db.
742      * @tc.expected: step2. reopen db successful.
743      */
744     option05.createIfNecessary = IS_NOT_NEED_CREATE;
745     delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option05);
746     ASSERT_TRUE(manager != nullptr && delegate != nullptr);
747 
748     /**
749      * @tc.steps: step3. get the system info before close db.
750      * @tc.expected: step3. reopen db successful.
751      */
752     MST_LOG("System info before close db again and again");
753     DistributedTestSysInfo sysInfo05;
754     sysInfo05.GetSysMemOccpy(FIRST);
755     sysInfo05.GetSysCpuUsage(FIRST, DEFAULT_INTEVAL);
756     sysInfo05.GetSysCurrentPower(FIRST, DEFAULT_COUNT, DEFAULT_INTEVAL);
757     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
758     delegate = nullptr;
759     delete manager;
760     manager = nullptr;
761 
762     delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option05);
763     ASSERT_TRUE(manager != nullptr && delegate != nullptr);
764 
765     /**
766      * @tc.steps: step4. get the system info after reopening db.
767      * @tc.expected: step4. the system has no memory leak.
768      */
769     MST_LOG("System info after opening db again and again");
770     sysInfo05.GetSysMemOccpy(SECOND);
771     sysInfo05.GetSysCpuUsage(SECOND, DEFAULT_INTEVAL);
772     sysInfo05.GetSysCurrentPower(SECOND, DEFAULT_COUNT, DEFAULT_INTEVAL);
773 
774     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
775     delegate = nullptr;
776     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == DBStatus::OK);
777     delete manager;
778     manager = nullptr;
779 }
780 
781 /*
782  * @tc.name: Performance 006
783  * @tc.desc: check the handler using when reopening by reopening db.
784  * @tc.type: System overhead
785  * @tc.require: SR000BUH3J
786  * @tc.author: luqianfu
787  */
788 HWTEST_F(DistributeddbKvCreateTest, Performance006, TestSize.Level2)
789 {
790     KvStoreDelegate *delegate = nullptr;
791     KvStoreDelegateManager *manager = nullptr;
792     /**
793      * @tc.steps: step1. create and close kv db.
794      * @tc.expected: step1. Construct that database exist.
795      */
796     KvOption option06 = g_kvOption;
797     option06.localOnly = IS_LOCAL_ONLY;
798     delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option06);
799     ASSERT_TRUE(manager != nullptr && delegate != nullptr);
800     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
801     delegate = nullptr;
802     delete manager;
803     manager = nullptr;
804     /**
805      * @tc.steps: step2. reopen by reopen db three times.
806      * @tc.expected: step2. reopen db successful and the system has no handle overflow.
807      */
808     option06.createIfNecessary = IS_NOT_NEED_CREATE;
809     delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option06);
810     ASSERT_TRUE(manager != nullptr && delegate != nullptr);
811     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
812     delegate = nullptr;
813     delete manager;
814     manager = nullptr;
815 
816     option06.createIfNecessary = IS_NEED_CREATE;
817     option06.localOnly = IS_NOT_LOCAL_ONLY;
818     delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option06);
819     ASSERT_TRUE(manager != nullptr && delegate != nullptr);
820     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
821     delegate = nullptr;
822     delete manager;
823     manager = nullptr;
824 
825     delegate = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option06);
826     ASSERT_TRUE(manager != nullptr && delegate != nullptr);
827     EXPECT_TRUE(manager->CloseKvStore(delegate) == OK);
828     delegate = nullptr;
829 
830     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == DBStatus::OK);
831     delete manager;
832     manager = nullptr;
833 }
834 
835 /*
836  * @tc.name: PathException 001
837  * @tc.desc: check it that can't create kv db without setting path with manager->SetKvStoreConfig(KV_CONFIG) interface.
838  * @tc.type: EXCEPTION
839  * @tc.require: SR000BUH3J
840  * @tc.author: luqianfu
841  */
842 HWTEST_F(DistributeddbKvCreateTest, PathException001, TestSize.Level2)
843 {
844     KvStoreDelegateManager *manager = nullptr;
845     KvStoreDelegate *delegate = nullptr;
846 
847     SetDir(DIRECTOR);
848     DelegateKvMgrCallback delegateKvMgrCallback;
849     function<void(DBStatus, KvStoreDelegate*)> function
850         = bind(&DelegateKvMgrCallback::Callback, &delegateKvMgrCallback, std::placeholders::_1, std::placeholders::_2);
851 
852     manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
853     ASSERT_NE(manager, nullptr);
854     /**
855      * @tc.steps: step1. create kv db without setting path with manager->SetKvStoreConfig(KV_CONFIG) interface.
856      * @tc.expected: step1. create and close db failed.
857      */
858     KvStoreDelegate::Option option = DistributedTestTools::TransferKvOptionType(g_kvOption);
859     manager->GetKvStore(STORE_ID_1, option, function);
860     EXPECT_EQ(delegateKvMgrCallback.GetStatus(), DBStatus::INVALID_ARGS);
861 
862     delegate = const_cast<KvStoreDelegate*>(delegateKvMgrCallback.GetKvStore());
863     EXPECT_EQ(delegate, nullptr);
864     EXPECT_EQ(manager->CloseKvStore(delegate), INVALID_ARGS);
865     EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), DBStatus::INVALID_ARGS);
866 
867     delete manager;
868     manager = nullptr;
869 }
870 
871 /*
872  * @tc.name: PathException 002
873  * @tc.desc: create kv db after setting no existing path.
874  * @tc.type: EXCEPTION
875  * @tc.require: SR000BUH3J
876  * @tc.author: luqianfu
877  */
878 HWTEST_F(DistributeddbKvCreateTest, PathException002, TestSize.Level2)
879 {
880     /**
881      * @tc.steps: step1. create kv db when setting no existing path.
882      * @tc.expected: step1. create db failed.
883      */
884     DelegateKvMgrCallback delegateKvMgrCallback;
885     function<void(DBStatus, KvStoreDelegate*)> function
886         = bind(&DelegateKvMgrCallback::Callback, &delegateKvMgrCallback, std::placeholders::_1, std::placeholders::_2);
887 
888     KvStoreConfig config;
889     config.dataDir = "/NOTFOUUD/PATH";
890 
891     KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
892     ASSERT_NE(manager, nullptr);
893     KvStoreDelegate::Option option = {true, true};
894 
895     EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::INVALID_ARGS);
896 
897     manager->GetKvStore(STORE_ID_1, option, function);
898     EXPECT_EQ(delegateKvMgrCallback.GetStatus(), INVALID_ARGS);
899 
900     KvStoreDelegate* delegate = const_cast<KvStoreDelegate*>(delegateKvMgrCallback.GetKvStore());
901     EXPECT_EQ(delegate, nullptr);
902     EXPECT_EQ(manager->CloseKvStore(delegate), INVALID_ARGS);
903     EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), DBStatus::INVALID_ARGS);
904     delete manager;
905     manager = nullptr;
906 }
907 
908 /*
909  * @tc.name: PathException 003
910  * @tc.desc: create kv db with invalid-char param.
911  * @tc.type: EXCEPTION
912  * @tc.require: SR000BUH3J
913  * @tc.author: luqianfu
914  */
915 HWTEST_F(DistributeddbKvCreateTest, PathException003, TestSize.Level2)
916 {
917     char chinese[5] = { static_cast<char>(0xD6), static_cast<char>(0xD0),
918         static_cast<char>(0xCE), static_cast<char>(0xC4) }; // not good ascii letters:<D6><D0><CE><C4>
919     std::string chStr = chinese;
920     MST_LOG("%s", chStr.c_str());
921 
922     DelegateKvMgrCallback exceptionCallback;
923     function<void(DBStatus, KvStoreDelegate*)> function
924         = bind(&DelegateKvMgrCallback::Callback, &exceptionCallback, std::placeholders::_1, std::placeholders::_2);
925     KvStoreConfig config;
926     config.dataDir = "";
927     /**
928      * @tc.steps: step1. create kv db with the path is null.
929      * @tc.expected: step1. create db failed.
930      */
931     KvStoreDelegateManager *manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
932     ASSERT_NE(manager, nullptr);
933     KvStoreDelegate::Option option = {true, true};
934     EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::INVALID_ARGS);
935     manager->GetKvStore(STORE_ID_1, option, function);
936     EXPECT_EQ(exceptionCallback.GetStatus(), INVALID_ARGS);
937     delete manager;
938     manager = nullptr;
939     /**
940      * @tc.steps: step1. create kv db with storeId="中文".
941      * @tc.expected: step1. create db failed.
942      */
943     SetDir(DIRECTOR);
944     config.dataDir = DIRECTOR;
945     manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, USER_ID_1);
946     ASSERT_NE(manager, nullptr);
947     EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::OK);
948     manager->GetKvStore(chStr, option, function);
949     EXPECT_EQ(exceptionCallback.GetStatus(), INVALID_ARGS);
950     delete manager;
951     manager = nullptr;
952 
953     /**
954      * @tc.steps: step2. create kv db with appId="中文".
955      * @tc.expected: step2. create db failed.
956      */
957     manager = new (std::nothrow) KvStoreDelegateManager(chStr, USER_ID_1);
958     ASSERT_NE(manager, nullptr);
959     EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::OK);
960     manager->GetKvStore(chStr, option, function);
961     EXPECT_EQ(exceptionCallback.GetStatus(), INVALID_ARGS);
962     delete manager;
963     manager = nullptr;
964     /**
965      * @tc.steps: step3. create kv db with userId="中文".
966      * @tc.expected: step3. create db failed.
967      */
968     manager = new (std::nothrow) KvStoreDelegateManager(APP_ID_1, chStr);
969     ASSERT_NE(manager, nullptr);
970     EXPECT_EQ(manager->SetKvStoreConfig(config), DBStatus::OK);
971     manager->GetKvStore(chStr, option, function);
972     EXPECT_EQ(exceptionCallback.GetStatus(), INVALID_ARGS);
973     delete manager;
974     manager = nullptr;
975 }
976 
977 /*
978  * @tc.name: PathException 004
979  * @tc.desc: create kv db with too long param.
980  * @tc.type: EXCEPTION
981  * @tc.require: SR000BUH3J
982  * @tc.author: luqianfu
983  */
984 HWTEST_F(DistributeddbKvCreateTest, PathException004, TestSize.Level2)
985 {
986     std::string storeTooLongID, appTooLongID, userTooLongID;
987     storeTooLongID.append(TWO_M_LONG_STRING, 'a');
988     appTooLongID.append(TWO_M_LONG_STRING, 'b');
989     userTooLongID.append(TWO_M_LONG_STRING, 'c');
990 
991     KvStoreDelegateManager *manager1 = nullptr;
992     KvStoreDelegateManager *manager2 = nullptr;
993     KvStoreDelegateManager *manager3 = nullptr;
994     KvStoreDelegate *delegate1 = nullptr;
995     KvStoreDelegate *delegate2 = nullptr;
996     KvStoreDelegate *delegate3 = nullptr;
997     /**
998      * @tc.steps: step1. create kv db with storeId=storeTooLongID.
999      * @tc.expected: step1. create db failed.
1000      */
1001     DBStatus status1 = DistributedTestTools::GetDelegateNotGood(manager1, delegate1,
1002         storeTooLongID, APP_ID_1, USER_ID_1, g_kvOption);
1003     EXPECT_EQ(delegate1, nullptr);
1004     EXPECT_EQ(manager1->CloseKvStore(delegate1), INVALID_ARGS);
1005     /**
1006      * @tc.steps: step2. create kv db with appId=appTooLongID.
1007      * @tc.expected: step2. create db failed.
1008      */
1009     DBStatus status2 = DistributedTestTools::GetDelegateNotGood(manager2, delegate2,
1010         USER_ID_1, appTooLongID, USER_ID_1, g_kvOption);
1011     EXPECT_EQ(delegate2, nullptr);
1012     EXPECT_EQ(manager2->CloseKvStore(delegate2), INVALID_ARGS);
1013     /**
1014      * @tc.steps: step3. create kv db with userId=userTooLongID.
1015      * @tc.expected: step3. create db failed.
1016      */
1017     DBStatus status3 = DistributedTestTools::GetDelegateNotGood(manager3, delegate3,
1018         USER_ID_1, APP_ID_1, userTooLongID, g_kvOption);
1019     EXPECT_EQ(delegate3, nullptr);
1020     EXPECT_EQ(manager3->CloseKvStore(delegate3), INVALID_ARGS);
1021 
1022     ASSERT_EQ(status1, DBStatus::INVALID_ARGS);
1023     ASSERT_EQ(status2, DBStatus::INVALID_ARGS);
1024     ASSERT_EQ(status3, DBStatus::INVALID_ARGS);
1025 
1026     delete manager1;
1027     manager1 = nullptr;
1028     delete manager2;
1029     manager2 = nullptr;
1030     delete manager3;
1031     manager3 = nullptr;
1032 }
1033 
1034 /*
1035  * @tc.name: PathException 005
1036  * @tc.desc: verify that the same DB can be reopen many times.
1037  * @tc.type: Stability
1038  * @tc.require: SR000BUH3J
1039  * @tc.author: luqianfu
1040  */
1041 HWTEST_F(DistributeddbKvCreateTest, PathException005, TestSize.Level2)
1042 {
1043     KvStoreDelegate *result = nullptr;
1044     KvStoreDelegateManager *manager = nullptr;
1045     /**
1046      * @tc.steps: step1. create and close kv db.
1047      * @tc.expected: step1. Construct that database exist.
1048      */
1049     KvOption option = g_kvOption;
1050     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1_1_2, option);
1051     ASSERT_TRUE(manager != nullptr && result != nullptr);
1052     EXPECT_EQ(manager->CloseKvStore(result), OK);
1053     result = nullptr;
1054 
1055     /**
1056      * @tc.steps: step2. reopen kv db five times.
1057      * @tc.expected: step2. reopen successfully and no memory exception when closing db.
1058      */
1059     option.createIfNecessary = IS_NEED_CREATE;
1060     KvStoreDelegate::Option optionUsedForGetStore = DistributedTestTools::TransferKvOptionType(option);
1061 
1062     DelegateKvMgrCallback delegateCallback;
1063     function<void(DBStatus, KvStoreDelegate*)> function
1064         = bind(&DelegateKvMgrCallback::Callback, &delegateCallback, std::placeholders::_1, std::placeholders::_2);
1065     KvStoreDelegate* delegate = nullptr;
1066     for (int operCnt = 1; operCnt <= OPER_CNT; ++operCnt) {
1067         manager->GetKvStore(STORE_ID_1, optionUsedForGetStore, function);
1068         EXPECT_EQ(delegateCallback.GetStatus(), OK);
1069         delegate = const_cast<KvStoreDelegate*>(delegateCallback.GetKvStore());
1070         EXPECT_NE(delegate, nullptr);
1071 
1072         EXPECT_EQ(manager->CloseKvStore(delegate), OK);
1073         delegate = nullptr;
1074     }
1075 
1076     EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), DBStatus::OK);
1077     delete manager;
1078     manager = nullptr;
1079 }
1080 
1081 /*
1082  * @tc.name: PathException 006
1083  * @tc.desc: verify that one delegate can be closed only one time.
1084  * @tc.type: EXCEPTION
1085  * @tc.require: SR000BUH3J
1086  * @tc.author: luqianfu
1087  */
1088 HWTEST_F(DistributeddbKvCreateTest, PathException006, TestSize.Level2)
1089 {
1090     KvStoreDelegate *result = nullptr;
1091     KvStoreDelegateManager *manager = nullptr;
1092     /**
1093      * @tc.steps: step1. create and close kv db.
1094      * @tc.expected: step1. Construct that database exist.
1095      */
1096     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1_1_2, g_kvOption);
1097     ASSERT_TRUE(manager != nullptr && result != nullptr);
1098     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
1099     result = nullptr;
1100 
1101     /**
1102      * @tc.steps: step2. create and close kv db more four times.
1103      * @tc.expected: step2. close successfully and no memory leak.
1104      */
1105     for (int operCnt = 1; operCnt <= OPER_CNT; ++operCnt) {
1106         EXPECT_EQ(manager->CloseKvStore(result), INVALID_ARGS);
1107     }
1108 
1109     EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
1110     delete manager;
1111     manager = nullptr;
1112 }
1113 
1114 /*
1115  * @tc.name: PathException 007
1116  * @tc.desc: open deleted kv db.
1117  * @tc.type: EXCEPTION
1118  * @tc.require: SR000BUH3J
1119  * @tc.author: luqianfu
1120  */
1121 HWTEST_F(DistributeddbKvCreateTest, PathException007, TestSize.Level2)
1122 {
1123     KvStoreDelegateManager *manager1 = nullptr;
1124     KvStoreDelegateManager *manager2 = nullptr;
1125     KvStoreDelegate *delegate1 = nullptr;
1126     KvStoreDelegate *delegate2 = nullptr;
1127     /**
1128      * @tc.steps: step1. create and close kv db.
1129      * @tc.expected: step1. Construct that database exist.
1130      */
1131     delegate1 = DistributedTestTools::GetDelegateSuccess(manager1, g_kvdbParameter1_1_2, g_kvOption);
1132     ASSERT_TRUE(manager1 != nullptr && delegate1 != nullptr);
1133     EXPECT_TRUE(manager1->CloseKvStore(delegate1) == OK);
1134     delegate1 = nullptr;
1135 
1136     /**
1137      * @tc.steps: step2. delete the DB.
1138      * @tc.expected: step2. delete successfully.
1139      */
1140     EXPECT_EQ(manager1->DeleteKvStore(STORE_ID_1), OK);
1141     delete manager1;
1142     manager1 = nullptr;
1143     /**
1144      * @tc.steps: step3. open the deleted DB with the mode createIfNecessary = IS_NOT_NEED_CREATE.
1145      * @tc.expected: step3. open failed and return error.
1146      */
1147     KvOption option = g_kvOption;
1148     option.createIfNecessary = IS_NOT_NEED_CREATE;
1149     option.localOnly = IS_LOCAL_ONLY;
1150     DBStatus status = DistributedTestTools::GetDelegateNotGood(manager2, delegate2,
1151         STORE_ID_1, APP_ID_1, USER_ID_2, option);
1152     EXPECT_TRUE(delegate2 == nullptr);
1153     EXPECT_EQ(manager2->CloseKvStore(delegate2), INVALID_ARGS);
1154     ASSERT_NE(status, OK);
1155 
1156     delete manager2;
1157     manager2 = nullptr;
1158 }
1159 
1160 /*
1161  * @tc.name: ConflictConfig 001
1162  * @tc.desc: check SetConflictResolutionPolicy interface with AUTO_LAST_WIN mode
1163  * @tc.type: LONGTIME TEST
1164  * @tc.require: SR000CCPOI
1165  * @tc.author: luqianfu
1166  */
1167 HWTEST_F(DistributeddbKvCreateTest, ConflictConfig001, TestSize.Level1)
1168 {
1169     KvStoreDelegate *conflictDelegate = nullptr;
1170     KvStoreDelegateManager *manager = nullptr;
1171     conflictDelegate = DistributedTestTools::GetDelegateSuccess(manager,
1172         g_kvdbParameter1_1_2, g_kvOption);
1173     ASSERT_TRUE(manager != nullptr && conflictDelegate != nullptr);
1174 
1175     /**
1176      * @tc.steps: step1. check SetConflictResolutionPolicy interface with AUTO_LAST_WIN mode.
1177      * @tc.expected: step1. return ok.
1178      */
1179     EXPECT_EQ(conflictDelegate->SetConflictResolutionPolicy(AUTO_LAST_WIN, nullptr), OK);
1180 
1181     EXPECT_TRUE(manager->CloseKvStore(conflictDelegate) == OK);
1182     conflictDelegate = nullptr;
1183     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1184     delete manager;
1185     manager = nullptr;
1186 }
1187 
1188 /*
1189  * @tc.name: ConflictConfig 002
1190  * @tc.desc: check SetConflictResolutionPolicy interface with CUSTOMER_RESOLUTION mode
1191  * @tc.type: LONGTIME TEST
1192  * @tc.require: SR000CCPOI
1193  * @tc.author: luqianfu
1194  */
1195 HWTEST_F(DistributeddbKvCreateTest, ConflictConfig002, TestSize.Level1)
1196 {
1197     KvStoreDelegate *conflictDelegate = nullptr;
1198     KvStoreDelegateManager *manager = nullptr;
1199     conflictDelegate = DistributedTestTools::GetDelegateSuccess(manager,
1200         g_kvdbParameter1_1_2, g_kvOption);
1201     ASSERT_TRUE(manager != nullptr && conflictDelegate != nullptr);
1202 
1203     /**
1204      * @tc.steps: step1. check SetConflictResolutionPolicy interface with CUSTOMER_RESOLUTION mode.
1205      * @tc.expected: step1. return error.
1206      */
1207     EXPECT_NE(conflictDelegate->SetConflictResolutionPolicy(CUSTOMER_RESOLUTION, nullptr), OK);
1208 
1209     EXPECT_TRUE(manager->CloseKvStore(conflictDelegate) == OK);
1210     conflictDelegate = nullptr;
1211     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1212     delete manager;
1213     manager = nullptr;
1214 }
1215 
1216 /*
1217  * @tc.name: ConflictConfig 003
1218  * @tc.desc: check SetConflictResolutionPolicy interface with invalid mode
1219  * @tc.type: LONGTIME TEST
1220  * @tc.require: SR000CCPOI
1221  * @tc.author: luqianfu
1222  */
1223 HWTEST_F(DistributeddbKvCreateTest, ConflictConfig003, TestSize.Level1)
1224 {
1225     KvStoreDelegate *conflictDelegate = nullptr;
1226     KvStoreDelegateManager *manager = nullptr;
1227     conflictDelegate = DistributedTestTools::GetDelegateSuccess(manager,
1228         g_kvdbParameter1_1_2, g_kvOption);
1229     ASSERT_TRUE(manager != nullptr && conflictDelegate != nullptr);
1230 
1231     /**
1232      * @tc.steps: step1. check SetConflictResolutionPolicy interface with invalid mode.
1233      * @tc.expected: step1. return ok.
1234      */
1235     EXPECT_EQ(conflictDelegate->SetConflictResolutionPolicy(static_cast<ResolutionPolicyType>(2), nullptr), DB_ERROR);
1236     EXPECT_EQ(conflictDelegate->SetConflictResolutionPolicy(static_cast<ResolutionPolicyType>(-1), nullptr), DB_ERROR);
1237 
1238     EXPECT_TRUE(manager->CloseKvStore(conflictDelegate) == OK);
1239     conflictDelegate = nullptr;
1240     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1241     delete manager;
1242     manager = nullptr;
1243 }
1244 
1245 /*
1246  * @tc.name: OptionParam 001
1247  * @tc.desc: verify that will check the option parameter when create encrypted DB.
1248  * @tc.type: FUNC
1249  * @tc.require: SR000CQDT4
1250  * @tc.author: fengxiaoyun
1251  */
1252 HWTEST_F(DistributeddbKvCreateTest, OptionParam001, TestSize.Level1)
1253 {
1254     vector<KvStoreDelegateManager *> manager = {nullptr, nullptr, nullptr};
1255     vector<KvStoreDelegate*> result = {nullptr, nullptr, nullptr, nullptr, nullptr};
1256     KvOption option;
1257     vector<uint8_t> password;
1258 
1259     /**
1260      * @tc.steps: step1. isEncryptedDb=true, passwd=NULL, cipher=DEFAULT when create db.
1261      * @tc.expected: step1. create failed and return INVALID_ARGS.
1262      */
1263     option.isEncryptedDb = true;
1264     option.cipher = CipherType::DEFAULT;
1265     option.passwd = NULL_PASSWD_VECTOR;
1266     DBStatus status;
1267     result[INDEX_ZEROTH] = DistributedTestTools::GetDelegateStatus(manager[INDEX_ZEROTH],
1268         status, g_kvdbParameter1, option);
1269     EXPECT_TRUE(manager[INDEX_ZEROTH] == nullptr && result[INDEX_ZEROTH] == nullptr);
1270     EXPECT_TRUE(status == INVALID_ARGS);
1271 
1272     /**
1273      * @tc.steps: step2. isEncryptedDb=true, passwd=a......(100B) when create db.
1274      * @tc.expected: step2. create successfully and return OK.
1275      */
1276     password.assign(VALUE_ONE_HUNDRED_BYTE, 'a');
1277     option.passwd = password;
1278     result[INDEX_FIRST] = DistributedTestTools::GetDelegateSuccess(manager[INDEX_ZEROTH], g_kvdbParameter1, option);
1279     ASSERT_TRUE(manager[INDEX_ZEROTH] != nullptr && result[INDEX_FIRST] != nullptr);
1280     EXPECT_EQ(manager[INDEX_ZEROTH]->CloseKvStore(result[INDEX_FIRST]), OK);
1281     result[INDEX_FIRST] = nullptr;
1282 
1283     /**
1284      * @tc.steps: step3. isEncryptedDb=true, passwd=a......(128B), cipher=AES_256_GCM when create db.
1285      * @tc.expected: step3. create successfully and return OK.
1286      */
1287     password.clear();
1288     password.assign(BATCH_RECORDS, 'a');
1289     option.cipher = CipherType::AES_256_GCM;
1290     option.passwd = password;
1291     result[INDEX_SECOND] = DistributedTestTools::GetDelegateSuccess(manager[INDEX_FIRST], g_kvdbParameter2, option);
1292     ASSERT_TRUE(manager[INDEX_FIRST] != nullptr && result[INDEX_SECOND] != nullptr);
1293     EXPECT_EQ(manager[INDEX_FIRST]->CloseKvStore(result[INDEX_SECOND]), OK);
1294     result[INDEX_SECOND] = nullptr;
1295 
1296     /**
1297      * @tc.steps: step4. isEncryptedDb=true, passwd=a......(129B), cipher=DEFAULT when create db.
1298      * @tc.expected: step4. create failed and return INVALID_ARGS.
1299      */
1300     password.clear();
1301     password.assign(PASSWD_BYTE, 'a');
1302     option.cipher = CipherType::DEFAULT;
1303     option.passwd = password;
1304     result[INDEX_THIRD] = DistributedTestTools::GetDelegateStatus(manager[INDEX_SECOND],
1305         status, g_kvdbParameter3, option);
1306     EXPECT_TRUE(manager[INDEX_SECOND] == nullptr && result[INDEX_THIRD] == nullptr);
1307     EXPECT_TRUE(status == INVALID_ARGS);
1308 
1309     /**
1310      * @tc.steps: step5. isEncryptedDb=false, passwd=a......(129B), cipher=DEFAULT when create db.
1311      * @tc.expected: step5. create successfully and return OK.
1312      */
1313     option.isEncryptedDb = false;
1314     result[INDEX_FORTH] = DistributedTestTools::GetDelegateSuccess(manager[INDEX_SECOND], g_kvdbParameter3, option);
1315     ASSERT_TRUE(manager[INDEX_SECOND] != nullptr && result[INDEX_FORTH] != nullptr);
1316     EXPECT_EQ(manager[INDEX_SECOND]->CloseKvStore(result[INDEX_FORTH]), OK);
1317     result[INDEX_FORTH] = nullptr;
1318 
1319     EXPECT_EQ(manager[INDEX_ZEROTH]->DeleteKvStore(STORE_ID_1), OK);
1320     EXPECT_EQ(manager[INDEX_FIRST]->DeleteKvStore(STORE_ID_2), OK);
1321     EXPECT_EQ(manager[INDEX_SECOND]->DeleteKvStore(STORE_ID_3), OK);
1322     for (auto &item : manager) {
1323         if (item != nullptr) {
1324             delete item;
1325         }
1326     }
1327 }
1328 
1329 /*
1330  * @tc.name: OptionParam 002
1331  * @tc.desc: verify that isEncryptedDb and passwd are consistent with the creation time can open an existing DB.
1332  * @tc.type: FUNC
1333  * @tc.require: SR000CQDT4
1334  * @tc.author: fengxiaoyun
1335  */
1336 HWTEST_F(DistributeddbKvCreateTest, OptionParam002, TestSize.Level1)
1337 {
1338     vector<KvStoreDelegateManager *> manager = {nullptr, nullptr, nullptr, nullptr};
1339     KvStoreDelegate *result = nullptr;
1340     KvOption option;
1341 
1342     /**
1343      * @tc.steps: step1. isEncryptedDb=true, passwd=p1, cipher=DEFAULT when create db1.
1344      * @tc.expected: step1. create successfully and return OK.
1345      */
1346     option.isEncryptedDb = true;
1347     option.passwd = PASSWD_VECTOR_1;
1348     result = DistributedTestTools::GetDelegateSuccess(manager[INDEX_ZEROTH], g_kvdbParameter1, option);
1349     ASSERT_TRUE(manager[INDEX_ZEROTH] != nullptr && result != nullptr);
1350     EXPECT_TRUE(manager[INDEX_ZEROTH]->CloseKvStore(result) == OK);
1351     result = nullptr;
1352     /**
1353      * @tc.steps: step2. isEncryptedDb=false, passwd=p1 when open db1.
1354      * @tc.expected: step2. open failed and return INVALID_PASSWD_OR_CORRUPTED_DB.
1355      */
1356     option.isEncryptedDb = false;
1357     DBStatus status;
1358     result = DistributedTestTools::GetDelegateStatus(manager[INDEX_FIRST], status, g_kvdbParameter1, option);
1359     EXPECT_TRUE(manager[INDEX_FIRST] == nullptr && result == nullptr);
1360     EXPECT_TRUE(status == INVALID_PASSWD_OR_CORRUPTED_DB);
1361 
1362     /**
1363      * @tc.steps: step3. isEncryptedDb=true, passwd=p2 when open db1.
1364      * @tc.expected: step3. open failed and return INVALID_PASSWD_OR_CORRUPTED_DB.
1365      */
1366     option.isEncryptedDb = true;
1367     option.passwd = PASSWD_VECTOR_2;
1368     result = DistributedTestTools::GetDelegateStatus(manager[INDEX_FIRST], status, g_kvdbParameter1, option);
1369     EXPECT_TRUE(manager[INDEX_FIRST] == nullptr && result == nullptr);
1370     EXPECT_TRUE(status == INVALID_PASSWD_OR_CORRUPTED_DB);
1371 
1372     /**
1373      * @tc.steps: step4. isEncryptedDb=true, passwd=p1 when open db1.
1374      * @tc.expected: step4. open successfully and return OK.
1375      */
1376     option.passwd = PASSWD_VECTOR_1;
1377     result = DistributedTestTools::GetDelegateSuccess(manager[INDEX_FIRST], g_kvdbParameter1, option);
1378     ASSERT_TRUE(manager[INDEX_FIRST] != nullptr && result != nullptr);
1379     EXPECT_TRUE(manager[INDEX_FIRST]->CloseKvStore(result) == OK);
1380     result = nullptr;
1381 
1382     /**
1383      * @tc.steps: step5. isEncryptedDb=false, passwd=p1, cipher=DEFAULT when create db2.
1384      * @tc.expected: step5. create successfully and return OK.
1385      */
1386     option.isEncryptedDb = false;
1387     result = DistributedTestTools::GetDelegateSuccess(manager[INDEX_SECOND], g_kvdbParameter2, option);
1388     ASSERT_TRUE(manager[INDEX_SECOND] != nullptr && result != nullptr);
1389     EXPECT_TRUE(manager[INDEX_SECOND]->CloseKvStore(result) == OK);
1390     result = nullptr;
1391 
1392     /**
1393      * @tc.steps: step6. isEncryptedDb=true, passwd=p1 when open db2.
1394      * @tc.expected: step6. open failed and return INVALID_PASSWD_OR_CORRUPTED_DB.
1395      */
1396     option.isEncryptedDb = true;
1397     result = DistributedTestTools::GetDelegateStatus(manager[INDEX_THIRD], status, g_kvdbParameter2, option);
1398     EXPECT_TRUE(manager[INDEX_THIRD] == nullptr && result == nullptr);
1399     EXPECT_TRUE(status == INVALID_PASSWD_OR_CORRUPTED_DB);
1400 
1401     /**
1402      * @tc.steps: step7. isEncryptedDb=false, passwd=p2 when open db2.
1403      * @tc.expected: step7. open successfully and return OK.
1404      */
1405     option.isEncryptedDb = false;
1406     option.passwd = PASSWD_VECTOR_2;
1407     result = DistributedTestTools::GetDelegateSuccess(manager[INDEX_THIRD], g_kvdbParameter2, option);
1408     ASSERT_TRUE(manager[INDEX_THIRD] != nullptr && result != nullptr);
1409     EXPECT_TRUE(manager[INDEX_THIRD]->CloseKvStore(result) == OK);
1410     result = nullptr;
1411     EXPECT_TRUE(manager[INDEX_FIRST]->DeleteKvStore(STORE_ID_1) == OK);
1412     EXPECT_TRUE(manager[INDEX_THIRD]->DeleteKvStore(STORE_ID_2) == OK);
1413     for (auto &item : manager) {
1414         if (item != nullptr) {
1415             delete item;
1416             item = nullptr;
1417         }
1418     }
1419 }
1420 
ReleaseManager(KvStoreDelegateManager * & manager)1421 void ReleaseManager(KvStoreDelegateManager *&manager)
1422 {
1423     if (manager != nullptr) {
1424         delete manager;
1425         manager = nullptr;
1426     }
1427     return;
1428 }
1429 /*
1430  * @tc.name: RekeyDb 001
1431  * @tc.desc: verify that can switching a non-encrypted database to an encrypted database by Rekey.
1432  * @tc.type: FUNC
1433  * @tc.require: SR000CQDT4
1434  * @tc.author: fengxiaoyun
1435  */
1436 HWTEST_F(DistributeddbKvCreateTest, RekeyDb001, TestSize.Level1)
1437 {
1438     KvStoreDelegateManager *manager = nullptr;
1439     KvStoreDelegate *result = nullptr;
1440     KvOption option;
1441 
1442     /**
1443      * @tc.steps: step1. create unencrypted db, use Rekey to update its passwd to NULL,
1444      * then close and open without passwd.
1445      * @tc.expected: step1. operate successfully and can open db again without passwd.
1446      */
1447     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1448     ASSERT_TRUE(manager != nullptr && result != nullptr);
1449     EXPECT_TRUE(result->Rekey(NULL_PASSWD) == OK);
1450     DistributedTestTools::CloseAndRelease(manager, result);
1451     option.createIfNecessary = false;
1452     option.isEncryptedDb = false;
1453     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1454     ASSERT_TRUE(manager != nullptr && result != nullptr);
1455     ASSERT_TRUE(DistributedTestTools::Put(*result, KEY_1, VALUE_1) == DBStatus::OK);
1456 
1457     /**
1458      * @tc.steps: step2. use Rekey to update db's passwd to p1=a......(100B), then close
1459      * and open again without passwd.
1460      * @tc.expected: step2. Rekey is ok, open db failed and return INVALID_PASSWD_OR_CORRUPTED_DB.
1461      */
1462     vector<uint8_t> passwordVector(VALUE_ONE_HUNDRED_BYTE, 'a');
1463     CipherPassword password;
1464     EXPECT_EQ(password.SetValue(passwordVector.data(), passwordVector.size()), CipherPassword::ErrorCode::OK);
1465     EXPECT_TRUE(result->Rekey(password) == OK);
1466     DistributedTestTools::CloseAndRelease(manager, result);
1467     DBStatus status;
1468     ASSERT_TRUE(DistributedTestTools::GetDelegateStatus(manager, status, g_kvdbParameter1, option) == nullptr);
1469     EXPECT_EQ(status, INVALID_PASSWD_OR_CORRUPTED_DB);
1470 
1471     /**
1472      * @tc.steps: step3. use p1 to open db and Get(k1), GetLocal(k1).
1473      * @tc.expected: step3. open successfully and Get(k1)=v1.
1474      */
1475     option.isEncryptedDb = true;
1476     option.passwd = passwordVector;
1477     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1478     ASSERT_TRUE(manager != nullptr && result != nullptr);
1479     Value valueResult = DistributedTestTools::Get(*result, KEY_1);
1480     EXPECT_TRUE(valueResult.size() != 0);
1481     EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_1));
1482 
1483     /**
1484      * @tc.steps: step4. use Rekey to update db's passwd to p2=passwordVector whose size is 128B, then close
1485      * and open again with p1.
1486      * @tc.expected: step4. Rekey is ok, open db failed and return INVALID_PASSWD_OR_CORRUPTED_DB.
1487      */
1488     passwordVector.assign(BATCH_RECORDS, 'a');
1489     EXPECT_EQ(password.SetValue(passwordVector.data(), passwordVector.size()), CipherPassword::ErrorCode::OK);
1490     EXPECT_TRUE(result->Rekey(password) == OK);
1491     DistributedTestTools::CloseAndRelease(manager, result);
1492     ASSERT_TRUE(DistributedTestTools::GetDelegateStatus(manager, status, g_kvdbParameter1, option) == nullptr);
1493     EXPECT_EQ(status, INVALID_PASSWD_OR_CORRUPTED_DB);
1494 
1495     /**
1496      * @tc.steps: step5. use p2 to open db and delete(k1).
1497      * @tc.expected: step5. operate successfully.
1498      */
1499     option.passwd = passwordVector;
1500     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1501     ASSERT_TRUE(manager != nullptr && result != nullptr);
1502     ASSERT_TRUE(DistributedTestTools::Delete(*result, KEY_1) == OK);
1503 
1504     /**
1505      * @tc.steps: step6. use Rekey to update db's passwd to p2=passwordVector whose size is 129B.
1506      * @tc.expected: step6. Rekey failed and return INVALID_ARGS.
1507      */
1508     passwordVector.assign(PASSWD_BYTE, 'a');
1509     EXPECT_EQ(password.SetValue(passwordVector.data(), passwordVector.size()), CipherPassword::ErrorCode::OVERSIZE);
1510 
1511     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
1512     result = nullptr;
1513     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1514     ReleaseManager(manager);
1515 }
1516 
1517 /*
1518  * @tc.name: RekeyDb 002
1519  * @tc.desc: verify that can change passwd of an encrypted database by Rekey.
1520  * @tc.type: FUNC
1521  * @tc.require: SR000CQDT4
1522  * @tc.author: fengxiaoyun
1523  */
1524 HWTEST_F(DistributeddbKvCreateTest, RekeyDb002, TestSize.Level1)
1525 {
1526     KvStoreDelegateManager *manager = nullptr;
1527     KvStoreDelegate *result = nullptr;
1528     KvOption option;
1529 
1530     /**
1531      * @tc.steps: step1. create encrypted db with p1=PASSWD_VECTOR_1.
1532      * @tc.expected: step1. create successfully.
1533      */
1534     option.isEncryptedDb = true;
1535     option.passwd = PASSWD_VECTOR_1;
1536     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1537     ASSERT_TRUE(manager != nullptr && result != nullptr);
1538 
1539     /**
1540      * @tc.steps: step2. use Rekey to update passwd to p1 and close db then open db again with unencrypted way.
1541      * @tc.expected: step2. the Rekey return OK, but open db failed.
1542      */
1543     EXPECT_TRUE(result->Rekey(g_passwd1) == OK);
1544     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
1545     result = nullptr;
1546     ReleaseManager(manager);
1547     option.createIfNecessary = false;
1548     option.isEncryptedDb = false;
1549     DBStatus status;
1550     result = DistributedTestTools::GetDelegateStatus(manager, status, g_kvdbParameter1, option);
1551     ASSERT_TRUE(result == nullptr);
1552     EXPECT_EQ(status, INVALID_PASSWD_OR_CORRUPTED_DB);
1553 
1554     /**
1555      * @tc.steps: step3. open db with passwd=p1 and putbatch(k1,v1)(k2,v2).
1556      * @tc.expected: step3. operate successfully.
1557      */
1558     option.isEncryptedDb = true;
1559     option.passwd = PASSWD_VECTOR_1;
1560     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1561     ASSERT_TRUE(manager != nullptr && result != nullptr);
1562     vector<Entry> entries1;
1563     entries1.push_back(ENTRY_1);
1564     entries1.push_back(ENTRY_2);
1565     EXPECT_TRUE(DistributedTestTools::PutBatch(*result, entries1) == OK);
1566 
1567     /**
1568      * @tc.steps: step4. use Rekey to update passwd to NULL and close db then open db with passwd=p1.
1569      * @tc.expected: step4. the Rekey return OK, but open db failed.
1570      */
1571     EXPECT_TRUE(result->Rekey(NULL_PASSWD) == OK);
1572     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
1573     result = nullptr;
1574     ReleaseManager(manager);
1575     result = DistributedTestTools::GetDelegateStatus(manager, status, g_kvdbParameter1, option);
1576     ASSERT_TRUE(result == nullptr);
1577     EXPECT_EQ(status, INVALID_PASSWD_OR_CORRUPTED_DB);
1578 
1579     /**
1580      * @tc.steps: step5. open db again with unencrypted way and Get(k1), GetLocal(k2).
1581      * @tc.expected: step5. open successfully and Get(k1)=v1, GetLocal(k2)=v2.
1582      */
1583     option.isEncryptedDb = false;
1584     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1585     ASSERT_TRUE(manager != nullptr && result != nullptr);
1586     vector<Entry> valueResult = DistributedTestTools::GetEntries(*result, KEY_EMPTY);
1587     ASSERT_TRUE(valueResult.size() == entries1.size());
1588 
1589     /**
1590      * @tc.steps: step6. use Rekey to update db's passwd to p2=a......(129B).
1591      * @tc.expected: step6. Reksy failed and return INVALID_ARGS.
1592      */
1593     vector<uint8_t> passwordVector(PASSWD_BYTE, 'a');
1594     CipherPassword password;
1595     EXPECT_EQ(password.SetValue(passwordVector.data(), passwordVector.size()), CipherPassword::ErrorCode::OVERSIZE);
1596 
1597     EXPECT_TRUE(manager->CloseKvStore(result) == OK);
1598     result = nullptr;
1599     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_1) == OK);
1600     ReleaseManager(manager);
1601 }
1602 
1603 #ifndef LOW_LEVEL_MEM_DEV
1604 /*
1605  * @tc.name: RekeyDb 003
1606  * @tc.desc: verify that do other operations during Rekey execution, the operation returns busy.
1607  * @tc.type: FUNC
1608  * @tc.require: SR000CQDT4
1609  * @tc.author: fengxiaoyun
1610  */
1611 HWTEST_F(DistributeddbKvCreateTest, RekeyDb003, TestSize.Level3)
1612 {
1613     KvStoreDelegateManager *manager = nullptr;
1614     KvStoreDelegate *result1 = nullptr;
1615     KvStoreDelegate *result2 = nullptr;
1616     KvOption option;
1617 
1618     /**
1619      * @tc.steps: step1. use Rekey to update passwd to p1=PASSWD_VECTOR_1.
1620      * @tc.expected: step1. create successfully.
1621      */
1622     result1 = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1623     ASSERT_TRUE(manager != nullptr && result1 != nullptr);
1624     std::vector<DistributedDB::Entry> entriesBatch;
1625     std::vector<DistributedDB::Key> allKeys;
1626     GenerateFixedRecords(entriesBatch, allKeys, ONE_HUNDRED_RECORDS, ONE_K_LONG_STRING, ONE_M_LONG_STRING);
1627     EXPECT_EQ(DistributedTestTools::PutBatch(*result1, entriesBatch), OK);
1628     bool rekeyFlag1 = false;
__anon0431985d0102() 1629     thread subThread1([&result1, &rekeyFlag1]() {
1630         DBStatus status = result1->Rekey(g_passwd1);
1631         EXPECT_TRUE(status == OK || status == BUSY);
1632         rekeyFlag1 = true;
1633         g_conditionKvVar.notify_one();
1634     });
1635     subThread1.detach();
1636 
1637     /**
1638      * @tc.steps: step2. Call the GetKvstore interface when Rekey.
1639      * @tc.expected: step2. the GetKvstore return BUSY.
1640      */
1641     option.createIfNecessary = false;
1642     KvStoreDelegateManager *managerRes = nullptr;
1643     DBStatus status;
1644     result2 = DistributedTestTools::GetDelegateStatus(managerRes, status, g_kvdbParameter1, option);
1645     EXPECT_TRUE(status == BUSY || status == OK);
1646     if (result2 != nullptr) {
1647         EXPECT_EQ(managerRes->CloseKvStore(result2), OK);
1648         ReleaseManager(managerRes);
1649     }
1650     std::mutex count;
1651     {
1652         std::unique_lock<std::mutex> lck(count);
__anon0431985d0202null1653         g_conditionKvVar.wait(lck, [&]{return rekeyFlag1;});
1654     }
1655 
1656     /**
1657      * @tc.steps: step3. put data to db when Rekey.
1658      * @tc.expected: step3. the put return BUSY.
1659      */
1660     bool rekeyFlag2 = false;
__anon0431985d0302() 1661     thread subThread2([&result1, &rekeyFlag2]() {
1662         DBStatus rekeyStatus = result1->Rekey(g_passwd2);
1663         EXPECT_TRUE(rekeyStatus == OK || rekeyStatus == BUSY);
1664         rekeyFlag2 = true;
1665         g_conditionKvVar.notify_all();
1666     });
1667     subThread2.detach();
1668     status = DistributedTestTools::Put(*result1, KEY_1, VALUE_1);
1669     EXPECT_TRUE(status == BUSY || status == OK);
1670     std::unique_lock<std::mutex> lck(count);
__anon0431985d0402null1671     g_conditionKvVar.wait(lck, [&]{return rekeyFlag2;});
1672     EXPECT_EQ(manager->CloseKvStore(result1), OK);
1673     EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
1674     ReleaseManager(manager);
1675 }
1676 #endif
1677 
1678 /*
1679  * @tc.name: RekeyDb 004
1680  * @tc.desc: verify that Rekey will return busy when there are multiple instances of the same KvStore.
1681  * @tc.type: FUNC
1682  * @tc.require: SR000CQDT4
1683  * @tc.author: fengxiaoyun
1684  */
1685 HWTEST_F(DistributeddbKvCreateTest, RekeyDb004, TestSize.Level1)
1686 {
1687     KvStoreDelegateManager *manager = nullptr;
1688     KvStoreDelegate *result1 = nullptr;
1689     KvStoreDelegate *result2 = nullptr;
1690     KvOption option;
1691 
1692     result1 = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1693     ASSERT_TRUE(manager != nullptr && result1 != nullptr);
1694     ReleaseManager(manager);
1695 
1696     /**
1697      * @tc.steps: step1. use GetKvstore to open another instances of the same KvStore.
1698      * @tc.expected: step1. open successfully.
1699      */
1700     option.createIfNecessary = false;
1701     result2 = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1702     ASSERT_TRUE(manager != nullptr && result2 != nullptr);
1703 
1704     /**
1705      * @tc.steps: step2. call Rekey.
1706      * @tc.expected: step2. Rekey returns BUSY.
1707      */
1708     EXPECT_EQ(result2->Rekey(g_passwd1), BUSY);
1709     EXPECT_EQ(manager->CloseKvStore(result1), OK);
1710     result1 = nullptr;
1711     EXPECT_EQ(manager->CloseKvStore(result2), OK);
1712     result2 = nullptr;
1713     EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
1714     ReleaseManager(manager);
1715 }
1716 
RunDbRekeyOne()1717 void RunDbRekeyOne()
1718 {
1719     KvStoreDelegateManager *manager1 = nullptr;
1720     KvStoreDelegate *result1 = nullptr;
1721     KvOption option;
1722     option.isEncryptedDb = true;
1723     option.passwd = PASSWD_VECTOR_1;
1724     result1 = DistributedTestTools::GetDelegateSuccess(manager1, g_kvdbParameter1, option);
1725     ASSERT_TRUE(manager1 != nullptr && result1 != nullptr);
1726     EXPECT_TRUE(result1->Rekey(g_passwd2) == OK);
1727     EXPECT_TRUE(manager1->CloseKvStore(result1) == OK);
1728     result1 = nullptr;
1729     EXPECT_TRUE(manager1->DeleteKvStore(STORE_ID_1) == OK);
1730     delete manager1;
1731     manager1 = nullptr;
1732 }
1733 
RunDbRekeyTwo()1734 void RunDbRekeyTwo()
1735 {
1736     KvStoreDelegateManager *manager2 = nullptr;
1737     KvStoreDelegate *result2 = nullptr;
1738     KvOption option;
1739     option.isEncryptedDb = true;
1740     option.passwd = PASSWD_VECTOR_2;
1741     result2 = DistributedTestTools::GetDelegateSuccess(manager2, g_kvdbParameter2, option);
1742     ASSERT_TRUE(manager2 != nullptr && result2 != nullptr);
1743     EXPECT_TRUE(result2->Rekey(g_passwd1) == OK);
1744     EXPECT_TRUE(manager2->CloseKvStore(result2) == OK);
1745     result2 = nullptr;
1746     EXPECT_TRUE(manager2->DeleteKvStore(STORE_ID_2) == OK);
1747     delete manager2;
1748     manager2 = nullptr;
1749 }
1750 
RunDbRekeyThree()1751 void RunDbRekeyThree()
1752 {
1753     KvStoreDelegateManager *manager3 = nullptr;
1754     KvStoreDelegate *result3 = nullptr;
1755     KvOption option;
1756     option.isEncryptedDb = true;
1757     option.passwd = PASSWD_VECTOR_1;
1758     result3 = DistributedTestTools::GetDelegateSuccess(manager3, g_kvdbParameter3, option);
1759     ASSERT_TRUE(manager3 != nullptr && result3 != nullptr);
1760     EXPECT_TRUE(result3->Rekey(NULL_PASSWD) == OK);
1761     EXPECT_TRUE(manager3->CloseKvStore(result3) == OK);
1762     result3 = nullptr;
1763     EXPECT_TRUE(manager3->DeleteKvStore(STORE_ID_3) == OK);
1764     delete manager3;
1765     manager3 = nullptr;
1766 }
1767 
RunDbRekeyFour()1768 void RunDbRekeyFour()
1769 {
1770     KvStoreDelegateManager *manager4 = nullptr;
1771     KvStoreDelegate *result4 = nullptr;
1772     KvOption option;
1773     result4 = DistributedTestTools::GetDelegateSuccess(manager4, g_kvdbParameter4, option);
1774     ASSERT_TRUE(manager4 != nullptr && result4 != nullptr);
1775     EXPECT_TRUE(result4->Rekey(g_passwd1) == OK);
1776     EXPECT_TRUE(manager4->CloseKvStore(result4) == OK);
1777     result4 = nullptr;
1778     EXPECT_TRUE(manager4->DeleteKvStore(STORE_ID_4) == OK);
1779     delete manager4;
1780     manager4 = nullptr;
1781 }
1782 
RunDbRekeyFive()1783 void RunDbRekeyFive()
1784 {
1785     KvStoreDelegateManager *manager5 = nullptr;
1786     KvStoreDelegate *result5 = nullptr;
1787     KvOption option;
1788     result5 = DistributedTestTools::GetDelegateSuccess(manager5, g_kvdbParameter5, option);
1789     ASSERT_TRUE(manager5 != nullptr && result5 != nullptr);
1790     vector<Entry> entries1;
1791     vector<Key> allKey1, allKey2;
1792     GenerateRecords(BATCH_RECORDS, DEFAULT_START, allKey1, entries1, K_SEARCH_3);
1793     DBStatus status = DistributedTestTools::PutBatch(*result5, entries1);
1794     ASSERT_TRUE(status == DBStatus::OK);
1795     DBStatus statusDelete = DistributedTestTools::DeleteBatch(*result5, allKey1);
1796     ASSERT_TRUE(statusDelete == DBStatus::OK);
1797     status = DistributedTestTools::Put(*result5, KEY_1, VALUE_1);
1798     ASSERT_TRUE(status == DBStatus::OK);
1799     Value valueResult = DistributedTestTools::Get(*result5, KEY_1);
1800     EXPECT_TRUE(valueResult.size() != 0);
1801     EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, VALUE_1));
1802     EXPECT_TRUE(manager5->CloseKvStore(result5) == OK);
1803     result5 = nullptr;
1804     EXPECT_TRUE(manager5->DeleteKvStore(STORE_ID_5) == OK);
1805     delete manager5;
1806     manager5 = nullptr;
1807 }
1808 /*
1809  * @tc.name: RekeyDb 005
1810  * @tc.desc: verify that calling Rekey interfaces on different DBs does not affect each other..
1811  * @tc.type: FUNC
1812  * @tc.require: SR000CQDT4
1813  * @tc.author: fengxiaoyun
1814  */
1815 HWTEST_F(DistributeddbKvCreateTest, RekeyDb005, TestSize.Level1)
1816 {
1817     /**
1818      * @tc.steps: step1. create thread1 to create db1 with passwd=p1, call Rekey to update passwd to p2=PASSSWD_2.
1819      * @tc.expected: step1. operate successfully.
1820      */
1821     thread subThread1(RunDbRekeyOne);
1822 
1823     /**
1824      * @tc.steps: step2. create thread2 to create db2 with passwd=p2, call Rekey to update passwd to p1=PASSSWD_1.
1825      * @tc.expected: step2. operate successfully.
1826      */
1827     thread subThread2(RunDbRekeyTwo);
1828 
1829     /**
1830      * @tc.steps: step3. create thread3 to create db3 with passwd=p1, call Rekey to update passwd to NULL_PASSWD.
1831      * @tc.expected: step3. operate successfully.
1832      */
1833     thread subThread3(RunDbRekeyThree);
1834 
1835     /**
1836      * @tc.steps: step4. create thread4 to create db4 without passwd, call Rekey to make db to be encrypted.
1837      * @tc.expected: step4. operate successfully.
1838      */
1839     thread subThread4(RunDbRekeyFour);
1840 
1841     /**
1842      * @tc.steps: step5. create thread5 to create db5 without passwd, then CRUD data to db5.
1843      * @tc.expected: step5. operate successfully.
1844      */
1845     thread subThread5(RunDbRekeyFive);
1846     subThread1.join();
1847     subThread2.join();
1848     subThread3.join();
1849     subThread5.join();
1850     subThread4.join();
1851 }
1852 
1853 /*
1854  * @tc.name: SpaceManger 001
1855  * @tc.desc: verify that can calculate the space size normally with the existing databaseID.
1856  * @tc.type: FUNC
1857  * @tc.require: SR000CQDT4
1858  * @tc.author: fengxiaoyun
1859  */
1860 #ifdef KV_CREATE
1861 HWTEST_F(DistributeddbKvCreateTest, SpaceManger001, TestSize.Level1)
1862 {
1863     KvStoreDelegateManager *manager = nullptr;
1864     KvStoreDelegate *result = nullptr;
1865     KvOption option;
1866     option.isEncryptedDb = true;
1867     option.passwd = PASSWD_VECTOR_1;
1868     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1869     ASSERT_TRUE(manager != nullptr && result != nullptr);
1870     EXPECT_EQ(manager->CloseKvStore(result), OK);
1871     result = nullptr;
1872 
1873     /**
1874      * @tc.steps: step1. call the GetKvStoreDiskSize() with storeId=store_Id_1.
1875      * @tc.expected: step1. call successfully and return dbSize1.
1876      */
1877     uint64_t dbSize1, dbSize2, dbSize3;
1878     dbSize1 = dbSize2 = dbSize3 = 0ul;
1879     EXPECT_EQ(manager->GetKvStoreDiskSize(STORE_ID_1, dbSize1), OK);
1880 
1881     /**
1882      * @tc.steps: step2. put 100 (keys,values) to db that every item's size = 1K.
1883      * @tc.expected: step2. operate successfully.
1884      */
1885     option.createIfNecessary = false;
1886     ReleaseManager(manager);
1887     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, option);
1888     ASSERT_TRUE(manager != nullptr && result != nullptr);
1889     vector<Entry> entriesBatch;
1890     vector<Key> allKeys;
1891     GenerateTenThousandRecords(NB_OPERATION_NUM, DEFAULT_START, allKeys, entriesBatch);
1892     EXPECT_EQ(DistributedTestTools::PutBatch(*result, entriesBatch), OK);
1893 
1894     /**
1895      * @tc.steps: step3. call the GetKvStoreDiskSize() with storeId=store_Id_1.
1896      * @tc.expected: step3. call successfully and return dbSize2, dbSize2>dbSize1.
1897      */
1898     EXPECT_EQ(manager->GetKvStoreDiskSize(STORE_ID_1, dbSize2), OK);
1899     EXPECT_GT(dbSize2, dbSize1);
1900 
1901     /**
1902      * @tc.steps: step4. delete the 100 (keys,values) that inserted in step2.
1903      * @tc.expected: step4. operate successfully.
1904      */
1905     EXPECT_EQ(DistributedTestTools::DeleteBatch(*result, allKeys), OK);
1906 
1907     /**
1908      * @tc.steps: step5. call the GetKvStoreDiskSize() with storeId=store_Id_1.
1909      * @tc.expected: step5. call successfully and return dbSize3, dbSize3>dbSize2 and dbSize3 != dbSize2.
1910      */
1911     EXPECT_EQ(manager->GetKvStoreDiskSize(STORE_ID_1, dbSize3), OK);
1912     EXPECT_GT(dbSize3, dbSize2);
1913     EXPECT_EQ(manager->CloseKvStore(result), OK);
1914     result = nullptr;
1915     EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
1916     ReleaseManager(manager);
1917 }
1918 
1919 /*
1920  * @tc.name: MergeRepeat 001
1921  * @tc.desc: verify that delete 9 items of (keys,v) that have the same value, can query remaining data's value is v.
1922  * @tc.type: FUNC
1923  * @tc.require: SR000CQDT4
1924  * @tc.author: fengxiaoyun
1925  */
1926 HWTEST_F(DistributeddbKvCreateTest, MergeRepeat001, TestSize.Level2)
1927 {
1928     KvStoreDelegateManager *manager = nullptr;
1929     KvStoreDelegate *result = nullptr;
1930     result = DistributedTestTools::GetDelegateSuccess(manager, g_kvdbParameter1, g_kvOption);
1931     ASSERT_TRUE(manager != nullptr && result != nullptr);
1932 
1933     /**
1934      * @tc.steps: step1. put 10 items of (keys,v) to db and GetKvStoreDiskSize() with storeId=store_Id_1.
1935      * @tc.expected: step1. put successfully and the GetKvStoreDiskSize() returns dbSize1.
1936      */
1937     uint64_t dbSize1, dbSize2;
1938     dbSize1 = dbSize2 = 0ul;
1939     EXPECT_EQ(manager->GetKvStoreDiskSize(STORE_ID_1, dbSize1), OK);
1940     vector<Entry> entriesBatch;
1941     vector<Key> allKeys;
1942     DistributedDB::Entry entry;
1943     int putCount = 0;
1944     entry.value.assign(TWO_M_LONG_STRING, 'v');
1945     GenerateTenThousandRecords(OPER_CNT_END, DEFAULT_START, allKeys, entriesBatch);
1946     for (vector<Entry>::iterator iter = entriesBatch.begin(); iter != entriesBatch.end(); iter++) {
1947         EXPECT_EQ(DistributedTestTools::Put(*result, iter->key, entry.value), OK);
1948         putCount++;
1949     }
1950 
1951     /**
1952      * @tc.steps: step2. call the GetKvStoreDiskSize() with storeId=store_Id_1.
1953      * @tc.expected: step2. call successfully and return dbSize2, dbSize2 > dbSize1.
1954      */
1955     EXPECT_EQ(manager->GetKvStoreDiskSize(STORE_ID_1, dbSize2), OK);
1956     EXPECT_TRUE(dbSize2 > dbSize1);
1957 
1958     /**
1959      * @tc.steps: step3. delete the 10 items of (keys,v) except the sixth item.
1960      * @tc.expected: step3. operate successfully.
1961      */
1962     allKeys.erase(allKeys.begin() + FIVE_SECONDS);
1963     DBStatus statusDelete = DistributedTestTools::DeleteBatch(*result, allKeys);
1964     EXPECT_EQ(statusDelete, DBStatus::OK);
1965 
1966     /**
1967      * @tc.steps: step4. Get(k6).
1968      * @tc.expected: step4. Get(k6)=v.
1969      */
1970     Value valueResult = DistributedTestTools::Get(*result, KEY_SEARCH_6);
1971     EXPECT_TRUE(valueResult.size() != 0);
1972     EXPECT_TRUE(DistributedTestTools::IsValueEquals(valueResult, entry.value));
1973     EXPECT_EQ(manager->CloseKvStore(result), OK);
1974     result = nullptr;
1975     EXPECT_EQ(manager->DeleteKvStore(STORE_ID_1), OK);
1976     delete manager;
1977     manager = nullptr;
1978 }
1979 #endif
1980 }
1981 #endif // OMIT_MULTI_VER
1982