1 /*
2  * Copyright (c) 2022 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 #include <condition_variable>
16 #include <gtest/gtest.h>
17 #include <vector>
18 
19 #include "block_data.h"
20 #include "dev_manager.h"
21 #include "distributed_kv_data_manager.h"
22 #include "file_ex.h"
23 #include "kv_store_nb_delegate.h"
24 #include "store_manager.h"
25 #include "sys/stat.h"
26 #include "types.h"
27 using namespace testing::ext;
28 using namespace OHOS::DistributedKv;
29 namespace OHOS::Test {
30 
Random(int32_t len)31 std::vector<uint8_t> Random(int32_t len)
32 {
33     return std::vector<uint8_t>(len, 'a');
34 }
35 
36 class SingleStoreImplTest : public testing::Test {
37 public:
38     class TestObserver : public KvStoreObserver {
39     public:
TestObserver()40         TestObserver()
41         {
42             // The time interval parameter is 5.
43             data_ = std::make_shared<OHOS::BlockData<bool>>(5, false);
44         }
OnChange(const ChangeNotification & notification)45         void OnChange(const ChangeNotification &notification) override
46         {
47             insert_ = notification.GetInsertEntries();
48             update_ = notification.GetUpdateEntries();
49             delete_ = notification.GetDeleteEntries();
50             deviceId_ = notification.GetDeviceId();
51             bool value = true;
52             data_->SetValue(value);
53         }
54         std::vector<Entry> insert_;
55         std::vector<Entry> update_;
56         std::vector<Entry> delete_;
57         std::string deviceId_;
58 
59         std::shared_ptr<OHOS::BlockData<bool>> data_;
60     };
61 
62     static void SetUpTestCase(void);
63     static void TearDownTestCase(void);
64     void SetUp();
65     void TearDown();
66 
67     std::shared_ptr<SingleKvStore> CreateKVStore(std::string storeIdTest, KvStoreType type, bool encrypt, bool backup);
68     std::shared_ptr<SingleKvStore> kvStore_;
69     static constexpr int MAX_RESULTSET_SIZE = 8;
70 };
71 
SetUpTestCase(void)72 void SingleStoreImplTest::SetUpTestCase(void)
73 {
74     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
75     mkdir(baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
76 }
77 
TearDownTestCase(void)78 void SingleStoreImplTest::TearDownTestCase(void)
79 {
80     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
81     StoreManager::GetInstance().Delete({ "SingleStoreImplTest" }, { "SingleKVStore" }, baseDir);
82 
83     (void)remove("/data/service/el1/public/database/SingleStoreImplTest/key");
84     (void)remove("/data/service/el1/public/database/SingleStoreImplTest/kvdb");
85     (void)remove("/data/service/el1/public/database/SingleStoreImplTest");
86 }
87 
SetUp(void)88 void SingleStoreImplTest::SetUp(void)
89 {
90     kvStore_ = CreateKVStore("SingleKVStore", SINGLE_VERSION, false, true);
91     if (kvStore_ == nullptr) {
92         kvStore_ = CreateKVStore("SingleKVStore", SINGLE_VERSION, false, true);
93     }
94     ASSERT_NE(kvStore_, nullptr);
95 }
96 
TearDown(void)97 void SingleStoreImplTest::TearDown(void)
98 {
99     AppId appId = { "SingleStoreImplTest" };
100     StoreId storeId = { "SingleKVStore" };
101     kvStore_ = nullptr;
102     auto status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
103     ASSERT_EQ(status, SUCCESS);
104     auto baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
105     status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
106     ASSERT_EQ(status, SUCCESS);
107 }
108 
CreateKVStore(std::string storeIdTest,KvStoreType type,bool encrypt,bool backup)109 std::shared_ptr<SingleKvStore> SingleStoreImplTest::CreateKVStore(std::string storeIdTest, KvStoreType type,
110     bool encrypt, bool backup)
111 {
112     Options options;
113     options.kvStoreType = type;
114     options.securityLevel = S1;
115     options.encrypt = encrypt;
116     options.area = EL1;
117     options.backup = backup;
118     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
119 
120     AppId appId = { "SingleStoreImplTest" };
121     StoreId storeId = { storeIdTest };
122     Status status = StoreManager::GetInstance().Delete(appId, storeId, options.baseDir);
123     return StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
124 }
125 
126 /**
127  * @tc.name: GetStoreId
128  * @tc.desc: get the store id of the kv store
129  * @tc.type: FUNC
130  * @tc.require: I4XVQQ
131  * @tc.author: Sven Wang
132  */
133 HWTEST_F(SingleStoreImplTest, GetStoreId, TestSize.Level0)
134 {
135     ASSERT_NE(kvStore_, nullptr);
136     auto storeId = kvStore_->GetStoreId();
137     ASSERT_EQ(storeId.storeId, "SingleKVStore");
138 }
139 
140 /**
141  * @tc.name: Put
142  * @tc.desc: put key-value data to the kv store
143  * @tc.type: FUNC
144  * @tc.require: I4XVQQ
145  * @tc.author: Sven Wang
146  */
147 HWTEST_F(SingleStoreImplTest, Put, TestSize.Level0)
148 {
149     ASSERT_NE(kvStore_, nullptr);
150     auto status = kvStore_->Put({ "Put Test" }, { "Put Value" });
151     ASSERT_EQ(status, SUCCESS);
152     status = kvStore_->Put({ "   Put Test" }, { "Put2 Value" });
153     ASSERT_EQ(status, SUCCESS);
154     Value value;
155     status = kvStore_->Get({ "Put Test" }, value);
156     ASSERT_EQ(status, SUCCESS);
157     ASSERT_EQ(value.ToString(), "Put2 Value");
158 }
159 
160 /**
161  * @tc.name: Put_Invalid_Key
162  * @tc.desc: put invalid key-value data to the device kv store and single kv store
163  * @tc.type: FUNC
164  * @tc.require: I4XVQQ
165  * @tc.author: wu fengshan
166  */
167 HWTEST_F(SingleStoreImplTest, Put_Invalid_Key, TestSize.Level0)
168 {
169     std::shared_ptr<SingleKvStore> kvStore;
170     AppId appId = { "SingleStoreImplTest" };
171     StoreId storeId = { "DeviceKVStore" };
172     kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true);
173     ASSERT_NE(kvStore, nullptr);
174 
175     size_t maxDevKeyLen = 897;
176     std::string str(maxDevKeyLen, 'a');
177     Blob key(str);
178     Blob value("test_value");
179     Status status = kvStore->Put(key, value);
180     EXPECT_EQ(status, INVALID_ARGUMENT);
181 
182     Blob key1("");
183     Blob value1("test_value1");
184     status = kvStore->Put(key1, value1);
185     EXPECT_EQ(status, INVALID_ARGUMENT);
186 
187     kvStore = nullptr;
188     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
189     ASSERT_EQ(status, SUCCESS);
190     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
191     status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
192     ASSERT_EQ(status, SUCCESS);
193 
194     size_t maxSingleKeyLen = 1025;
195     std::string str1(maxSingleKeyLen, 'b');
196     Blob key2(str1);
197     Blob value2("test_value2");
198     status = kvStore_->Put(key2, value2);
199     EXPECT_EQ(status, INVALID_ARGUMENT);
200 
201     status = kvStore_->Put(key1, value1);
202     EXPECT_EQ(status, INVALID_ARGUMENT);
203 }
204 
205 /**
206  * @tc.name: PutBatch
207  * @tc.desc: put some key-value data to the kv store
208  * @tc.type: FUNC
209  * @tc.require: I4XVQQ
210  * @tc.author: Sven Wang
211  */
212 HWTEST_F(SingleStoreImplTest, PutBatch, TestSize.Level0)
213 {
214     ASSERT_NE(kvStore_, nullptr);
215     std::vector<Entry> entries;
216     for (int i = 0; i < 10; ++i) {
217         Entry entry;
218         entry.key = std::to_string(i).append("_k");
219         entry.value = std::to_string(i).append("_v");
220         entries.push_back(entry);
221     }
222     auto status = kvStore_->PutBatch(entries);
223     ASSERT_EQ(status, SUCCESS);
224 }
225 
226 /**
227  * @tc.name: Delete
228  * @tc.desc: delete the value of the key
229  * @tc.type: FUNC
230  * @tc.require: I4XVQQ
231  * @tc.author: Sven Wang
232  */
233 HWTEST_F(SingleStoreImplTest, Delete, TestSize.Level0)
234 {
235     ASSERT_NE(kvStore_, nullptr);
236     auto status = kvStore_->Put({ "Put Test" }, { "Put Value" });
237     ASSERT_EQ(status, SUCCESS);
238     Value value;
239     status = kvStore_->Get({ "Put Test" }, value);
240     ASSERT_EQ(status, SUCCESS);
241     ASSERT_EQ(std::string("Put Value"), value.ToString());
242     status = kvStore_->Delete({ "Put Test" });
243     ASSERT_EQ(status, SUCCESS);
244     value = {};
245     status = kvStore_->Get({ "Put Test" }, value);
246     ASSERT_EQ(status, KEY_NOT_FOUND);
247     ASSERT_EQ(std::string(""), value.ToString());
248 }
249 
250 /**
251  * @tc.name: DeleteBatch
252  * @tc.desc: delete the values of the keys
253  * @tc.type: FUNC
254  * @tc.require: I4XVQQ
255  * @tc.author: Sven Wang
256  */
257 HWTEST_F(SingleStoreImplTest, DeleteBatch, TestSize.Level0)
258 {
259     ASSERT_NE(kvStore_, nullptr);
260     std::vector<Entry> entries;
261     for (int i = 0; i < 10; ++i) {
262         Entry entry;
263         entry.key = std::to_string(i).append("_k");
264         entry.value = std::to_string(i).append("_v");
265         entries.push_back(entry);
266     }
267     auto status = kvStore_->PutBatch(entries);
268     ASSERT_EQ(status, SUCCESS);
269     std::vector<Key> keys;
270     for (int i = 0; i < 10; ++i) {
271         Key key = std::to_string(i).append("_k");
272         keys.push_back(key);
273     }
274     status = kvStore_->DeleteBatch(keys);
275     ASSERT_EQ(status, SUCCESS);
276     for (int i = 0; i < 10; ++i) {
277         Value value;
278         status = kvStore_->Get(keys[i], value);
279         ASSERT_EQ(status, KEY_NOT_FOUND);
280         ASSERT_EQ(value.ToString(), std::string(""));
281     }
282 }
283 
284 /**
285  * @tc.name: Transaction
286  * @tc.desc: do transaction
287  * @tc.type: FUNC
288  * @tc.require: I4XVQQ
289  * @tc.author: Sven Wang
290  */
291 HWTEST_F(SingleStoreImplTest, Transaction, TestSize.Level0)
292 {
293     ASSERT_NE(kvStore_, nullptr);
294     auto status = kvStore_->StartTransaction();
295     ASSERT_EQ(status, SUCCESS);
296     status = kvStore_->Commit();
297     ASSERT_EQ(status, SUCCESS);
298 
299     status = kvStore_->StartTransaction();
300     ASSERT_EQ(status, SUCCESS);
301     status = kvStore_->Rollback();
302     ASSERT_EQ(status, SUCCESS);
303 }
304 
305 /**
306  * @tc.name: SubscribeKvStore
307  * @tc.desc: subscribe local
308  * @tc.type: FUNC
309  * @tc.require: I4XVQQ
310  * @tc.author: Sven Wang
311  */
312 HWTEST_F(SingleStoreImplTest, SubscribeKvStore, TestSize.Level0)
313 {
314     ASSERT_NE(kvStore_, nullptr);
315     auto observer = std::make_shared<TestObserver>();
316     auto status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
317     ASSERT_EQ(status, SUCCESS);
318     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, observer);
319     ASSERT_EQ(status, SUCCESS);
320     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_CLOUD, observer);
321     ASSERT_EQ(status, SUCCESS);
322     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
323     ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
324     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, observer);
325     ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
326     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_CLOUD, observer);
327     ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
328     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
329     ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
330     bool invalidValue = false;
331     observer->data_->Clear(invalidValue);
332     status = kvStore_->Put({ "Put Test" }, { "Put Value" });
333     ASSERT_EQ(status, SUCCESS);
334     ASSERT_TRUE(observer->data_->GetValue());
335     ASSERT_EQ(observer->insert_.size(), 1);
336     ASSERT_EQ(observer->update_.size(), 0);
337     ASSERT_EQ(observer->delete_.size(), 0);
338     observer->data_->Clear(invalidValue);
339     status = kvStore_->Put({ "Put Test" }, { "Put Value1" });
340     ASSERT_EQ(status, SUCCESS);
341     ASSERT_TRUE(observer->data_->GetValue());
342     ASSERT_EQ(observer->insert_.size(), 0);
343     ASSERT_EQ(observer->update_.size(), 1);
344     ASSERT_EQ(observer->delete_.size(), 0);
345     observer->data_->Clear(invalidValue);
346     status = kvStore_->Delete({ "Put Test" });
347     ASSERT_EQ(status, SUCCESS);
348     ASSERT_TRUE(observer->data_->GetValue());
349     ASSERT_EQ(observer->insert_.size(), 0);
350     ASSERT_EQ(observer->update_.size(), 0);
351     ASSERT_EQ(observer->delete_.size(), 1);
352 }
353 
354 /**
355  * @tc.name: SubscribeKvStore002
356  * @tc.desc: subscribe local
357  * @tc.type: FUNC
358  * @tc.require: I4XVQQ
359  * @tc.author: Hollokin
360  */
361 HWTEST_F(SingleStoreImplTest, SubscribeKvStore002, TestSize.Level0)
362 {
363     ASSERT_NE(kvStore_, nullptr);
364     std::shared_ptr<TestObserver> subscribedObserver;
365     std::shared_ptr<TestObserver> unSubscribedObserver;
366     for (int i = 0; i < 15; ++i) {
367         auto observer = std::make_shared<TestObserver>();
368         auto status1 = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
369         auto status2 = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, observer);
370         if (i < 8) {
371             ASSERT_EQ(status1, SUCCESS);
372             ASSERT_EQ(status2, SUCCESS);
373             subscribedObserver = observer;
374         } else {
375             ASSERT_EQ(status1, OVER_MAX_LIMITS);
376             ASSERT_EQ(status2, OVER_MAX_LIMITS);
377             unSubscribedObserver = observer;
378         }
379     }
380 
381     auto status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, subscribedObserver);
382     ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
383 
384     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, {});
385     ASSERT_EQ(status, INVALID_ARGUMENT);
386 
387     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, subscribedObserver);
388     ASSERT_EQ(status, STORE_ALREADY_SUBSCRIBE);
389 
390     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_ALL, subscribedObserver);
391     ASSERT_EQ(status, SUCCESS);
392 
393     status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, subscribedObserver);
394     ASSERT_EQ(status, SUCCESS);
395     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, subscribedObserver);
396     ASSERT_EQ(status, SUCCESS);
397 
398     status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_ALL, subscribedObserver);
399     ASSERT_EQ(status, SUCCESS);
400     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, unSubscribedObserver);
401     ASSERT_EQ(status, SUCCESS);
402     subscribedObserver = unSubscribedObserver;
403     status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, subscribedObserver);
404     ASSERT_EQ(status, SUCCESS);
405     auto observer = std::make_shared<TestObserver>();
406     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
407     ASSERT_EQ(status, SUCCESS);
408     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
409     ASSERT_EQ(status, SUCCESS);
410     observer = std::make_shared<TestObserver>();
411     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
412     ASSERT_EQ(status, OVER_MAX_LIMITS);
413 }
414 
415 /**
416  * @tc.name: UnsubscribeKvStore
417  * @tc.desc: unsubscribe
418  * @tc.type: FUNC
419  * @tc.require: I4XVQQ
420  * @tc.author: Sven Wang
421  */
422 HWTEST_F(SingleStoreImplTest, UnsubscribeKvStore, TestSize.Level0)
423 {
424     ASSERT_NE(kvStore_, nullptr);
425     auto observer = std::make_shared<TestObserver>();
426     auto status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
427     ASSERT_EQ(status, SUCCESS);
428     status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, observer);
429     ASSERT_EQ(status, SUCCESS);
430     status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_CLOUD, observer);
431     ASSERT_EQ(status, SUCCESS);
432     status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_REMOTE, observer);
433     ASSERT_EQ(status, STORE_NOT_SUBSCRIBE);
434     status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
435     ASSERT_EQ(status, SUCCESS);
436     status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
437     ASSERT_EQ(status, STORE_NOT_SUBSCRIBE);
438     status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
439     ASSERT_EQ(status, STORE_NOT_SUBSCRIBE);
440     status = kvStore_->SubscribeKvStore(SUBSCRIBE_TYPE_LOCAL, observer);
441     ASSERT_EQ(status, SUCCESS);
442     status = kvStore_->UnSubscribeKvStore(SUBSCRIBE_TYPE_ALL, observer);
443     ASSERT_EQ(status, SUCCESS);
444 }
445 
446 /**
447  * @tc.name: GetEntries
448  * @tc.desc: get entries by prefix
449  * @tc.type: FUNC
450  * @tc.require: I4XVQQ
451  * @tc.author: Sven Wang
452  */
453 HWTEST_F(SingleStoreImplTest, GetEntries_Prefix, TestSize.Level0)
454 {
455     ASSERT_NE(kvStore_, nullptr);
456     std::vector<Entry> input;
457     for (int i = 0; i < 10; ++i) {
458         Entry entry;
459         entry.key = std::to_string(i).append("_k");
460         entry.value = std::to_string(i).append("_v");
461         input.push_back(entry);
462     }
463     auto status = kvStore_->PutBatch(input);
464     ASSERT_EQ(status, SUCCESS);
465     std::vector<Entry> output;
466     status = kvStore_->GetEntries({ "" }, output);
467     ASSERT_EQ(status, SUCCESS);
468     std::sort(output.begin(), output.end(),
__anonf1f971f10102(const Entry &entry, const Entry &sentry) 469         [](const Entry &entry, const Entry &sentry) { return entry.key.Data() < sentry.key.Data(); });
470     for (int i = 0; i < 10; ++i) {
471         ASSERT_TRUE(input[i].key == output[i].key);
472         ASSERT_TRUE(input[i].value == output[i].value);
473     }
474 }
475 
476 /**
477  * @tc.name: GetEntries_Less_Prefix
478  * @tc.desc: get entries by prefix and the key size less than sizeof(uint32_t)
479  * @tc.type: FUNC
480  * @tc.require: I4XVQQ
481  * @tc.author: wu fengshan
482  */
483 HWTEST_F(SingleStoreImplTest, GetEntries_Less_Prefix, TestSize.Level0)
484 {
485     std::shared_ptr<SingleKvStore> kvStore;
486     AppId appId = { "SingleStoreImplTest" };
487     StoreId storeId = { "DeviceKVStore" };
488     kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true);
489     ASSERT_NE(kvStore, nullptr);
490 
491     std::vector<Entry> input;
492     for (int i = 0; i < 10; ++i) {
493         Entry entry;
494         entry.key = std::to_string(i).append("_k");
495         entry.value = std::to_string(i).append("_v");
496         input.push_back(entry);
497     }
498     auto status = kvStore->PutBatch(input);
499     ASSERT_EQ(status, SUCCESS);
500     std::vector<Entry> output;
501     status = kvStore->GetEntries({ "1" }, output);
502     ASSERT_NE(output.empty(), true);
503     ASSERT_EQ(status, SUCCESS);
504 
505     kvStore = nullptr;
506     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
507     ASSERT_EQ(status, SUCCESS);
508     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
509     status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
510     ASSERT_EQ(status, SUCCESS);
511 
512     status = kvStore_->PutBatch(input);
513     ASSERT_EQ(status, SUCCESS);
514     std::vector<Entry> output1;
515     status = kvStore_->GetEntries({ "1" }, output1);
516     ASSERT_NE(output1.empty(), true);
517     ASSERT_EQ(status, SUCCESS);
518 }
519 
520 /**
521  * @tc.name: GetEntries_Greater_Prefix
522  * @tc.desc: get entries by prefix and the key size is greater than  sizeof(uint32_t)
523  * @tc.type: FUNC
524  * @tc.require: I4XVQQ
525  * @tc.author: wu fengshan
526  */
527 HWTEST_F(SingleStoreImplTest, GetEntries_Greater_Prefix, TestSize.Level0)
528 {
529     std::shared_ptr<SingleKvStore> kvStore;
530     AppId appId = { "SingleStoreImplTest" };
531     StoreId storeId = { "DeviceKVStore" };
532     kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true);
533     ASSERT_NE(kvStore, nullptr);
534 
535     size_t keyLen = sizeof(uint32_t);
536     std::vector<Entry> input;
537     for (int i = 1; i < 10; ++i) {
538         Entry entry;
539         std::string str(keyLen, i + '0');
540         entry.key = str;
541         entry.value = std::to_string(i).append("_v");
542         input.push_back(entry);
543     }
544     auto status = kvStore->PutBatch(input);
545     ASSERT_EQ(status, SUCCESS);
546     std::vector<Entry> output;
547     std::string str1(keyLen, '1');
548     status = kvStore->GetEntries(str1, output);
549     ASSERT_NE(output.empty(), true);
550     ASSERT_EQ(status, SUCCESS);
551 
552     kvStore = nullptr;
553     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
554     ASSERT_EQ(status, SUCCESS);
555     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
556     status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
557     ASSERT_EQ(status, SUCCESS);
558 
559     status = kvStore_->PutBatch(input);
560     ASSERT_EQ(status, SUCCESS);
561     std::vector<Entry> output1;
562     status = kvStore_->GetEntries(str1, output1);
563     ASSERT_NE(output1.empty(), true);
564     ASSERT_EQ(status, SUCCESS);
565 }
566 
567 /**
568  * @tc.name: GetEntries
569  * @tc.desc: get entries by query
570  * @tc.type: FUNC
571  * @tc.require: I4XVQQ
572  * @tc.author: Sven Wang
573  */
574 HWTEST_F(SingleStoreImplTest, GetEntries_DataQuery, TestSize.Level0)
575 {
576     ASSERT_NE(kvStore_, nullptr);
577     std::vector<Entry> input;
578     for (int i = 0; i < 10; ++i) {
579         Entry entry;
580         entry.key = std::to_string(i).append("_k");
581         entry.value = std::to_string(i).append("_v");
582         input.push_back(entry);
583     }
584     auto status = kvStore_->PutBatch(input);
585     ASSERT_EQ(status, SUCCESS);
586     DataQuery query;
587     query.InKeys({ "0_k", "1_k" });
588     std::vector<Entry> output;
589     status = kvStore_->GetEntries(query, output);
590     ASSERT_EQ(status, SUCCESS);
591     std::sort(output.begin(), output.end(),
__anonf1f971f10202(const Entry &entry, const Entry &sentry) 592         [](const Entry &entry, const Entry &sentry) { return entry.key.Data() < sentry.key.Data(); });
593     ASSERT_LE(output.size(), 2);
594     for (size_t i = 0; i < output.size(); ++i) {
595         ASSERT_TRUE(input[i].key == output[i].key);
596         ASSERT_TRUE(input[i].value == output[i].value);
597     }
598 }
599 
600 /**
601  * @tc.name: GetResultSet
602  * @tc.desc: get result set by prefix
603  * @tc.type: FUNC
604  * @tc.require: I4XVQQ
605  * @tc.author: Sven Wang
606  */
607 HWTEST_F(SingleStoreImplTest, GetResultSet_Prefix, TestSize.Level0)
608 {
609     ASSERT_NE(kvStore_, nullptr);
610     std::vector<Entry> input;
__anonf1f971f10302(const Key &entry, const Key &sentry) 611     auto cmp = [](const Key &entry, const Key &sentry) { return entry.Data() < sentry.Data(); };
612     std::map<Key, Value, decltype(cmp)> dictionary(cmp);
613     for (int i = 0; i < 10; ++i) {
614         Entry entry;
615         entry.key = std::to_string(i).append("_k");
616         entry.value = std::to_string(i).append("_v");
617         dictionary[entry.key] = entry.value;
618         input.push_back(entry);
619     }
620     auto status = kvStore_->PutBatch(input);
621     ASSERT_EQ(status, SUCCESS);
622     std::shared_ptr<KvStoreResultSet> output;
623     status = kvStore_->GetResultSet({ "" }, output);
624     ASSERT_EQ(status, SUCCESS);
625     ASSERT_NE(output, nullptr);
626     ASSERT_EQ(output->GetCount(), 10);
627     int count = 0;
628     while (output->MoveToNext()) {
629         count++;
630         Entry entry;
631         output->GetEntry(entry);
632         ASSERT_EQ(entry.value.Data(), dictionary[entry.key].Data());
633     }
634     ASSERT_EQ(count, output->GetCount());
635 }
636 
637 /**
638  * @tc.name: GetResultSet
639  * @tc.desc: get result set by query
640  * @tc.type: FUNC
641  * @tc.require: I4XVQQ
642  * @tc.author: Sven Wang
643  */
644 HWTEST_F(SingleStoreImplTest, GetResultSet_Query, TestSize.Level0)
645 {
646     ASSERT_NE(kvStore_, nullptr);
647     std::vector<Entry> input;
__anonf1f971f10402(const Key &entry, const Key &sentry) 648     auto cmp = [](const Key &entry, const Key &sentry) { return entry.Data() < sentry.Data(); };
649     std::map<Key, Value, decltype(cmp)> dictionary(cmp);
650     for (int i = 0; i < 10; ++i) {
651         Entry entry;
652         entry.key = std::to_string(i).append("_k");
653         entry.value = std::to_string(i).append("_v");
654         dictionary[entry.key] = entry.value;
655         input.push_back(entry);
656     }
657     auto status = kvStore_->PutBatch(input);
658     ASSERT_EQ(status, SUCCESS);
659     DataQuery query;
660     query.InKeys({ "0_k", "1_k" });
661     std::shared_ptr<KvStoreResultSet> output;
662     status = kvStore_->GetResultSet(query, output);
663     ASSERT_EQ(status, SUCCESS);
664     ASSERT_NE(output, nullptr);
665     ASSERT_LE(output->GetCount(), 2);
666     int count = 0;
667     while (output->MoveToNext()) {
668         count++;
669         Entry entry;
670         output->GetEntry(entry);
671         ASSERT_EQ(entry.value.Data(), dictionary[entry.key].Data());
672     }
673     ASSERT_EQ(count, output->GetCount());
674 }
675 
676 /**
677  * @tc.name: CloseResultSet
678  * @tc.desc: close the result set
679  * @tc.type: FUNC
680  * @tc.require: I4XVQQ
681  * @tc.author: Sven Wang
682  */
683 HWTEST_F(SingleStoreImplTest, CloseResultSet, TestSize.Level0)
684 {
685     ASSERT_NE(kvStore_, nullptr);
686     std::vector<Entry> input;
__anonf1f971f10502(const Key &entry, const Key &sentry) 687     auto cmp = [](const Key &entry, const Key &sentry) { return entry.Data() < sentry.Data(); };
688     std::map<Key, Value, decltype(cmp)> dictionary(cmp);
689     for (int i = 0; i < 10; ++i) {
690         Entry entry;
691         entry.key = std::to_string(i).append("_k");
692         entry.value = std::to_string(i).append("_v");
693         dictionary[entry.key] = entry.value;
694         input.push_back(entry);
695     }
696     auto status = kvStore_->PutBatch(input);
697     ASSERT_EQ(status, SUCCESS);
698     DataQuery query;
699     query.InKeys({ "0_k", "1_k" });
700     std::shared_ptr<KvStoreResultSet> output;
701     status = kvStore_->GetResultSet(query, output);
702     ASSERT_EQ(status, SUCCESS);
703     ASSERT_NE(output, nullptr);
704     ASSERT_LE(output->GetCount(), 2);
705     auto outputTmp = output;
706     status = kvStore_->CloseResultSet(output);
707     ASSERT_EQ(status, SUCCESS);
708     ASSERT_EQ(output, nullptr);
709     ASSERT_EQ(outputTmp->GetCount(), KvStoreResultSet::INVALID_COUNT);
710     ASSERT_EQ(outputTmp->GetPosition(), KvStoreResultSet::INVALID_POSITION);
711     ASSERT_EQ(outputTmp->MoveToFirst(), false);
712     ASSERT_EQ(outputTmp->MoveToLast(), false);
713     ASSERT_EQ(outputTmp->MoveToNext(), false);
714     ASSERT_EQ(outputTmp->MoveToPrevious(), false);
715     ASSERT_EQ(outputTmp->Move(1), false);
716     ASSERT_EQ(outputTmp->MoveToPosition(1), false);
717     ASSERT_EQ(outputTmp->IsFirst(), false);
718     ASSERT_EQ(outputTmp->IsLast(), false);
719     ASSERT_EQ(outputTmp->IsBeforeFirst(), false);
720     ASSERT_EQ(outputTmp->IsAfterLast(), false);
721     Entry entry;
722     ASSERT_EQ(outputTmp->GetEntry(entry), ALREADY_CLOSED);
723 }
724 
725 /**
726  * @tc.name: ResultSetMaxSizeTest
727  * @tc.desc: test if kv supports 8 resultSets at the same time
728  * @tc.type: FUNC
729  * @tc.require: I4XVQQ
730  * @tc.author: Yang Qing
731  */
732 HWTEST_F(SingleStoreImplTest, ResultSetMaxSizeTest_Query, TestSize.Level0)
733 {
734     ASSERT_NE(kvStore_, nullptr);
735     /**
736      * @tc.steps:step1. Put the entry into the database.
737      * @tc.expected: step1. Returns SUCCESS.
738      */
739     std::vector<Entry> input;
740     for (int i = 0; i < 10; ++i) {
741         Entry entry;
742         entry.key = "k_" + std::to_string(i);
743         entry.value = "v_" + std::to_string(i);
744         input.push_back(entry);
745     }
746     auto status = kvStore_->PutBatch(input);
747     ASSERT_EQ(status, SUCCESS);
748     /**
749      * @tc.steps:step2. Get the resultset.
750      * @tc.expected: step2. Returns SUCCESS.
751      */
752     DataQuery query;
753     query.KeyPrefix("k_");
754     std::vector<std::shared_ptr<KvStoreResultSet>> outputs(MAX_RESULTSET_SIZE + 1);
755     for (int i = 0; i < MAX_RESULTSET_SIZE; i++) {
756         std::shared_ptr<KvStoreResultSet> output;
757         status = kvStore_->GetResultSet(query, outputs[i]);
758         ASSERT_EQ(status, SUCCESS);
759     }
760     /**
761      * @tc.steps:step3. Get the resultset while resultset size is over the limit.
762      * @tc.expected: step3. Returns OVER_MAX_LIMITS.
763      */
764     status = kvStore_->GetResultSet(query, outputs[MAX_RESULTSET_SIZE]);
765     ASSERT_EQ(status, OVER_MAX_LIMITS);
766     /**
767      * @tc.steps:step4. Close the resultset and getting the resultset is retried
768      * @tc.expected: step4. Returns SUCCESS.
769      */
770     status = kvStore_->CloseResultSet(outputs[0]);
771     ASSERT_EQ(status, SUCCESS);
772     status = kvStore_->GetResultSet(query, outputs[MAX_RESULTSET_SIZE]);
773     ASSERT_EQ(status, SUCCESS);
774 
775     for (int i = 1; i <= MAX_RESULTSET_SIZE; i++) {
776         status = kvStore_->CloseResultSet(outputs[i]);
777         ASSERT_EQ(status, SUCCESS);
778     }
779 }
780 
781 /**
782  * @tc.name: ResultSetMaxSizeTest
783  * @tc.desc: test if kv supports 8 resultSets at the same time
784  * @tc.type: FUNC
785  * @tc.require: I4XVQQ
786  * @tc.author: Yang Qing
787  */
788 HWTEST_F(SingleStoreImplTest, ResultSetMaxSizeTest_Prefix, TestSize.Level0)
789 {
790     ASSERT_NE(kvStore_, nullptr);
791     /**
792      * @tc.steps:step1. Put the entry into the database.
793      * @tc.expected: step1. Returns SUCCESS.
794      */
795     std::vector<Entry> input;
796     for (int i = 0; i < 10; ++i) {
797         Entry entry;
798         entry.key = "k_" + std::to_string(i);
799         entry.value = "v_" + std::to_string(i);
800         input.push_back(entry);
801     }
802     auto status = kvStore_->PutBatch(input);
803     ASSERT_EQ(status, SUCCESS);
804     /**
805      * @tc.steps:step2. Get the resultset.
806      * @tc.expected: step2. Returns SUCCESS.
807      */
808     std::vector<std::shared_ptr<KvStoreResultSet>> outputs(MAX_RESULTSET_SIZE + 1);
809     for (int i = 0; i < MAX_RESULTSET_SIZE; i++) {
810         std::shared_ptr<KvStoreResultSet> output;
811         status = kvStore_->GetResultSet({ "k_i" }, outputs[i]);
812         ASSERT_EQ(status, SUCCESS);
813     }
814     /**
815      * @tc.steps:step3. Get the resultset while resultset size is over the limit.
816      * @tc.expected: step3. Returns OVER_MAX_LIMITS.
817      */
818     status = kvStore_->GetResultSet({ "" }, outputs[MAX_RESULTSET_SIZE]);
819     ASSERT_EQ(status, OVER_MAX_LIMITS);
820     /**
821      * @tc.steps:step4. Close the resultset and getting the resultset is retried
822      * @tc.expected: step4. Returns SUCCESS.
823      */
824     status = kvStore_->CloseResultSet(outputs[0]);
825     ASSERT_EQ(status, SUCCESS);
826     status = kvStore_->GetResultSet({ "" }, outputs[MAX_RESULTSET_SIZE]);
827     ASSERT_EQ(status, SUCCESS);
828 
829     for (int i = 1; i <= MAX_RESULTSET_SIZE; i++) {
830         status = kvStore_->CloseResultSet(outputs[i]);
831         ASSERT_EQ(status, SUCCESS);
832     }
833 }
834 
835 /**
836  * @tc.name: MaxLogSizeTest
837  * @tc.desc: test if the default max limit of wal is 200MB
838  * @tc.type: FUNC
839  * @tc.require: I4XVQQ
840  * @tc.author: Yang Qing
841  */
842 HWTEST_F(SingleStoreImplTest, MaxLogSizeTest, TestSize.Level0)
843 {
844     ASSERT_NE(kvStore_, nullptr);
845     /**
846      * @tc.steps:step1. Put the random entry into the database.
847      * @tc.expected: step1. Returns SUCCESS.
848      */
849     std::string key;
850     std::vector<uint8_t> value = Random(4 * 1024 * 1024);
851     key = "test0";
852     EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
853     key = "test1";
854     EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
855     key = "test2";
856     EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
857     /**
858      * @tc.steps:step2. Get the resultset.
859      * @tc.expected: step2. Returns SUCCESS.
860      */
861     std::shared_ptr<KvStoreResultSet> output;
862     auto status = kvStore_->GetResultSet({ "" }, output);
863     ASSERT_EQ(status, SUCCESS);
864     ASSERT_NE(output, nullptr);
865     ASSERT_EQ(output->GetCount(), 3);
866     EXPECT_EQ(output->MoveToFirst(), true);
867     /**
868      * @tc.steps:step3. Put more data into the database.
869      * @tc.expected: step3. Returns SUCCESS.
870      */
871     for (int i = 0; i < 50; i++) {
872         key = "test_" + std::to_string(i);
873         EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
874     }
875     /**
876      * @tc.steps:step4. Put more data into the database while the log size is over the limit.
877      * @tc.expected: step4. Returns LOG_LIMITS_ERROR.
878      */
879     key = "test3";
880     EXPECT_EQ(kvStore_->Put(key, value), WAL_OVER_LIMITS);
881     EXPECT_EQ(kvStore_->Delete(key), WAL_OVER_LIMITS);
882     EXPECT_EQ(kvStore_->StartTransaction(), WAL_OVER_LIMITS);
883     /**
884      * @tc.steps:step5. Close the resultset and put again.
885      * @tc.expected: step4. Return SUCCESS.
886      */
887 
888     status = kvStore_->CloseResultSet(output);
889     ASSERT_EQ(status, SUCCESS);
890     EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
891 }
892 
893 /**
894  * @tc.name: MaxTest002
895  * @tc.desc: test if the default max limit of wal is 200MB
896  * @tc.type: FUNC
897  * @tc.require: I4XVQQ
898  * @tc.author: Yang Qing
899  */
900 HWTEST_F(SingleStoreImplTest, MaxLogSizeTest002, TestSize.Level0)
901 {
902     ASSERT_NE(kvStore_, nullptr);
903     /**
904      * @tc.steps:step1. Put the random entry into the database.
905      * @tc.expected: step1. Returns SUCCESS.
906      */
907     std::string key;
908     std::vector<uint8_t> value = Random(4 * 1024 * 1024);
909     key = "test0";
910     EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
911     key = "test1";
912     EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
913     key = "test2";
914     EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
915     /**
916      * @tc.steps:step2. Get the resultset.
917      * @tc.expected: step2. Returns SUCCESS.
918      */
919     std::shared_ptr<KvStoreResultSet> output;
920     auto status = kvStore_->GetResultSet({ "" }, output);
921     ASSERT_EQ(status, SUCCESS);
922     ASSERT_NE(output, nullptr);
923     ASSERT_EQ(output->GetCount(), 3);
924     EXPECT_EQ(output->MoveToFirst(), true);
925     /**
926      * @tc.steps:step3. Put more data into the database.
927      * @tc.expected: step3. Returns SUCCESS.
928      */
929     for (int i = 0; i < 50; i++) {
930         key = "test_" + std::to_string(i);
931         EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
932     }
933     /**
934      * @tc.steps:step4. Put more data into the database while the log size is over the limit.
935      * @tc.expected: step4. Returns LOG_LIMITS_ERROR.
936      */
937     key = "test3";
938     EXPECT_EQ(kvStore_->Put(key, value), WAL_OVER_LIMITS);
939     EXPECT_EQ(kvStore_->Delete(key), WAL_OVER_LIMITS);
940     EXPECT_EQ(kvStore_->StartTransaction(), WAL_OVER_LIMITS);
941     status = kvStore_->CloseResultSet(output);
942     ASSERT_EQ(status, SUCCESS);
943     /**
944      * @tc.steps:step5. Close the database and then open the database,put again.
945      * @tc.expected: step4. Return SUCCESS.
946      */
947     AppId appId = { "SingleStoreImplTest" };
948     StoreId storeId = { "SingleKVStore" };
949     Options options;
950     options.kvStoreType = SINGLE_VERSION;
951     options.securityLevel = S1;
952     options.encrypt = false;
953     options.area = EL1;
954     options.backup = true;
955     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
956 
957     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
958     ASSERT_EQ(status, SUCCESS);
959     kvStore_ = nullptr;
960     kvStore_ = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
961     ASSERT_EQ(status, SUCCESS);
962 
963     status = kvStore_->GetResultSet({ "" }, output);
964     ASSERT_EQ(status, SUCCESS);
965     ASSERT_NE(output, nullptr);
966     EXPECT_EQ(output->MoveToFirst(), true);
967 
968     EXPECT_EQ(kvStore_->Put(key, value), SUCCESS);
969     status = kvStore_->CloseResultSet(output);
970     ASSERT_EQ(status, SUCCESS);
971 }
972 
973 /**
974  * @tc.name: Move_Offset
975  * @tc.desc: Move the ResultSet Relative Distance
976  * @tc.type: FUNC
977  * @tc.require: I4XVQQ
978  * @tc.author: wu fengshan
979  */
980 HWTEST_F(SingleStoreImplTest, Move_Offset, TestSize.Level0)
981 {
982     std::vector<Entry> input;
983     for (int i = 0; i < 10; ++i) {
984         Entry entry;
985         entry.key = std::to_string(i).append("_k");
986         entry.value = std::to_string(i).append("_v");
987         input.push_back(entry);
988     }
989     auto status = kvStore_->PutBatch(input);
990     ASSERT_EQ(status, SUCCESS);
991 
992     Key prefix = "2";
993     std::shared_ptr<KvStoreResultSet> output;
994     status = kvStore_->GetResultSet(prefix, output);
995     ASSERT_EQ(status, SUCCESS);
996     ASSERT_NE(output, nullptr);
997 
998     auto outputTmp = output;
999     ASSERT_EQ(outputTmp->Move(1), true);
1000     status = kvStore_->CloseResultSet(output);
1001     ASSERT_EQ(status, SUCCESS);
1002     ASSERT_EQ(output, nullptr);
1003 
1004     std::shared_ptr<SingleKvStore> kvStore;
1005     AppId appId = { "SingleStoreImplTest" };
1006     StoreId storeId = { "DeviceKVStore" };
1007     kvStore = CreateKVStore(storeId.storeId, DEVICE_COLLABORATION, false, true);
1008     ASSERT_NE(kvStore, nullptr);
1009 
1010     status = kvStore->PutBatch(input);
1011     ASSERT_EQ(status, SUCCESS);
1012     std::shared_ptr<KvStoreResultSet> output1;
1013     status = kvStore->GetResultSet(prefix, output1);
1014     ASSERT_EQ(status, SUCCESS);
1015     ASSERT_NE(output1, nullptr);
1016     auto outputTmp1 = output1;
1017     ASSERT_EQ(outputTmp1->Move(1), true);
1018     status = kvStore->CloseResultSet(output1);
1019     ASSERT_EQ(status, SUCCESS);
1020     ASSERT_EQ(output1, nullptr);
1021 
1022     kvStore = nullptr;
1023     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1024     ASSERT_EQ(status, SUCCESS);
1025     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1026     status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
1027     ASSERT_EQ(status, SUCCESS);
1028 }
1029 
1030 /**
1031  * @tc.name: GetCount
1032  * @tc.desc: close the result set
1033  * @tc.type: FUNC
1034  * @tc.require: I4XVQQ
1035  * @tc.author: Sven Wang
1036  */
1037 HWTEST_F(SingleStoreImplTest, GetCount, TestSize.Level0)
1038 {
1039     ASSERT_NE(kvStore_, nullptr);
1040     std::vector<Entry> input;
__anonf1f971f10602(const Key &entry, const Key &sentry) 1041     auto cmp = [](const Key &entry, const Key &sentry) { return entry.Data() < sentry.Data(); };
1042     std::map<Key, Value, decltype(cmp)> dictionary(cmp);
1043     for (int i = 0; i < 10; ++i) {
1044         Entry entry;
1045         entry.key = std::to_string(i).append("_k");
1046         entry.value = std::to_string(i).append("_v");
1047         dictionary[entry.key] = entry.value;
1048         input.push_back(entry);
1049     }
1050     auto status = kvStore_->PutBatch(input);
1051     ASSERT_EQ(status, SUCCESS);
1052     DataQuery query;
1053     query.InKeys({ "0_k", "1_k" });
1054     int count = 0;
1055     status = kvStore_->GetCount(query, count);
1056     ASSERT_EQ(status, SUCCESS);
1057     ASSERT_EQ(count, 2);
1058     query.Reset();
1059     status = kvStore_->GetCount(query, count);
1060     ASSERT_EQ(status, SUCCESS);
1061     ASSERT_EQ(count, 10);
1062 }
1063 
ChangeOwnerToService(std::string baseDir,std::string hashId)1064 void ChangeOwnerToService(std::string baseDir, std::string hashId)
1065 {
1066     static constexpr int ddmsId = 3012;
1067     std::string path = baseDir;
1068     chown(path.c_str(), ddmsId, ddmsId);
1069     path = path + "/kvdb";
1070     chown(path.c_str(), ddmsId, ddmsId);
1071     path = path + "/" + hashId;
1072     chown(path.c_str(), ddmsId, ddmsId);
1073     path = path + "/single_ver";
1074     chown(path.c_str(), ddmsId, ddmsId);
1075     chown((path + "/meta").c_str(), ddmsId, ddmsId);
1076     chown((path + "/cache").c_str(), ddmsId, ddmsId);
1077     path = path + "/main";
1078     chown(path.c_str(), ddmsId, ddmsId);
1079     chown((path + "/gen_natural_store.db").c_str(), ddmsId, ddmsId);
1080     chown((path + "/gen_natural_store.db-shm").c_str(), ddmsId, ddmsId);
1081     chown((path + "/gen_natural_store.db-wal").c_str(), ddmsId, ddmsId);
1082 }
1083 
1084 /**
1085  * @tc.name: RemoveDeviceData
1086  * @tc.desc: remove local device data
1087  * @tc.type: FUNC
1088  * @tc.require: I4XVQQ
1089  * @tc.author: Sven Wang
1090  */
1091 HWTEST_F(SingleStoreImplTest, RemoveDeviceData, TestSize.Level0)
1092 {
1093     auto store = CreateKVStore("DeviceKVStore", DEVICE_COLLABORATION, false, true);
1094     ASSERT_NE(store, nullptr);
1095     std::vector<Entry> input;
__anonf1f971f10702(const Key &entry, const Key &sentry) 1096     auto cmp = [](const Key &entry, const Key &sentry) { return entry.Data() < sentry.Data(); };
1097     std::map<Key, Value, decltype(cmp)> dictionary(cmp);
1098     for (int i = 0; i < 10; ++i) {
1099         Entry entry;
1100         entry.key = std::to_string(i).append("_k");
1101         entry.value = std::to_string(i).append("_v");
1102         dictionary[entry.key] = entry.value;
1103         input.push_back(entry);
1104     }
1105     auto status = store->PutBatch(input);
1106     ASSERT_EQ(status, SUCCESS);
1107     int count = 0;
1108     status = store->GetCount({}, count);
1109     ASSERT_EQ(status, SUCCESS);
1110     ASSERT_EQ(count, 10);
1111     ChangeOwnerToService(
1112         "/data/service/el1/public/database/SingleStoreImplTest",
1113         "703c6ec99aa7226bb9f6194cdd60e1873ea9ee52faebd55657ade9f5a5cc3cbd");
1114     status = store->RemoveDeviceData(DevManager::GetInstance().GetLocalDevice().networkId);
1115     ASSERT_EQ(status, SUCCESS);
1116     status = store->GetCount({}, count);
1117     ASSERT_EQ(status, SUCCESS);
1118     ASSERT_EQ(count, 10);
1119     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1120     status = StoreManager::GetInstance().Delete({ "SingleStoreImplTest" }, { "DeviceKVStore" }, baseDir);
1121     ASSERT_EQ(status, SUCCESS);
1122 }
1123 
1124 /**
1125  * @tc.name: GetSecurityLevel
1126  * @tc.desc: get security level
1127  * @tc.type: FUNC
1128  * @tc.require: I4XVQQ
1129  * @tc.author: Sven Wang
1130  */
1131 HWTEST_F(SingleStoreImplTest, GetSecurityLevel, TestSize.Level0)
1132 {
1133     ASSERT_NE(kvStore_, nullptr);
1134     SecurityLevel securityLevel = NO_LABEL;
1135     auto status = kvStore_->GetSecurityLevel(securityLevel);
1136     ASSERT_EQ(status, SUCCESS);
1137     ASSERT_EQ(securityLevel, S1);
1138 }
1139 
1140 /**
1141  * @tc.name: RegisterSyncCallback
1142  * @tc.desc: register the data sync callback
1143  * @tc.type: FUNC
1144  * @tc.require: I4XVQQ
1145  * @tc.author: Sven Wang
1146  */
1147 HWTEST_F(SingleStoreImplTest, RegisterSyncCallback, TestSize.Level0)
1148 {
1149     ASSERT_NE(kvStore_, nullptr);
1150     class TestSyncCallback : public KvStoreSyncCallback {
1151     public:
SyncCompleted(const map<std::string,Status> & results)1152         void SyncCompleted(const map<std::string, Status> &results) override
1153         {
1154         }
SyncCompleted(const std::map<std::string,Status> & results,uint64_t sequenceId)1155         void SyncCompleted(const std::map<std::string, Status> &results, uint64_t sequenceId) override
1156         {
1157         }
1158     };
1159     auto callback = std::make_shared<TestSyncCallback>();
1160     auto status = kvStore_->RegisterSyncCallback(callback);
1161     ASSERT_EQ(status, SUCCESS);
1162 }
1163 
1164 /**
1165  * @tc.name: UnRegisterSyncCallback
1166  * @tc.desc: unregister the data sync callback
1167  * @tc.type: FUNC
1168  * @tc.require: I4XVQQ
1169  * @tc.author: Sven Wang
1170  */
1171 HWTEST_F(SingleStoreImplTest, UnRegisterSyncCallback, TestSize.Level0)
1172 {
1173     ASSERT_NE(kvStore_, nullptr);
1174     class TestSyncCallback : public KvStoreSyncCallback {
1175     public:
SyncCompleted(const map<std::string,Status> & results)1176         void SyncCompleted(const map<std::string, Status> &results) override
1177         {
1178         }
SyncCompleted(const std::map<std::string,Status> & results,uint64_t sequenceId)1179         void SyncCompleted(const std::map<std::string, Status> &results, uint64_t sequenceId) override
1180         {
1181         }
1182     };
1183     auto callback = std::make_shared<TestSyncCallback>();
1184     auto status = kvStore_->RegisterSyncCallback(callback);
1185     ASSERT_EQ(status, SUCCESS);
1186     status = kvStore_->UnRegisterSyncCallback();
1187     ASSERT_EQ(status, SUCCESS);
1188 }
1189 
1190 /**
1191 * @tc.name: disableBackup
1192 * @tc.desc: Disable backup
1193 * @tc.type: FUNC
1194 * @tc.require:
1195 * @tc.author: Wang Kai
1196 */
1197 HWTEST_F(SingleStoreImplTest, disableBackup, TestSize.Level0)
1198 {
1199     AppId appId = { "SingleStoreImplTest" };
1200     StoreId storeId = { "SingleKVStoreNoBackup" };
1201     std::shared_ptr<SingleKvStore> kvStoreNoBackup;
1202     kvStoreNoBackup = CreateKVStore(storeId, SINGLE_VERSION, true, false);
1203     ASSERT_NE(kvStoreNoBackup, nullptr);
1204     auto baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1205     auto status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1206     ASSERT_EQ(status, SUCCESS);
1207     status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
1208     ASSERT_EQ(status, SUCCESS);
1209 }
1210 
1211 /**
1212  * @tc.name: PutOverMaxValue
1213  * @tc.desc: put key-value data to the kv store and the value size  over the limits
1214  * @tc.type: FUNC
1215  * @tc.require: I605H3
1216  * @tc.author: Wang Kai
1217  */
1218 HWTEST_F(SingleStoreImplTest, PutOverMaxValue, TestSize.Level0)
1219 {
1220     ASSERT_NE(kvStore_, nullptr);
1221     std::string value;
1222     int maxsize = 1024 * 1024;
1223     for (int i = 0; i <= maxsize; i++) {
1224         value += "test";
1225     }
1226     Value valuePut(value);
1227     auto status = kvStore_->Put({ "Put Test" }, valuePut);
1228     ASSERT_EQ(status, INVALID_ARGUMENT);
1229 }
1230 /**
1231  * @tc.name: DeleteOverMaxKey
1232  * @tc.desc: delete the values of the keys and the key size  over the limits
1233  * @tc.type: FUNC
1234  * @tc.require: I605H3
1235  * @tc.author: Wang Kai
1236  */
1237 HWTEST_F(SingleStoreImplTest, DeleteOverMaxKey, TestSize.Level0)
1238 {
1239     ASSERT_NE(kvStore_, nullptr);
1240     std::string str;
1241     int maxsize = 1024;
1242     for (int i = 0; i <= maxsize; i++) {
1243         str += "key";
1244     }
1245     Key key(str);
1246     auto status = kvStore_->Put(key, "Put Test");
1247     ASSERT_EQ(status, INVALID_ARGUMENT);
1248     Value value;
1249     status = kvStore_->Get(key, value);
1250     ASSERT_EQ(status, INVALID_ARGUMENT);
1251     status = kvStore_->Delete(key);
1252     ASSERT_EQ(status, INVALID_ARGUMENT);
1253 }
1254 
1255 /**
1256  * @tc.name: GetEntriesOverMaxKey
1257  * @tc.desc: get entries the by prefix and the prefix size  over the limits
1258  * @tc.type: FUNC
1259  * @tc.require: I605H3
1260  * @tc.author: Wang Kai
1261  */
1262 HWTEST_F(SingleStoreImplTest, GetEntriesOverMaxPrefix, TestSize.Level0)
1263 {
1264     ASSERT_NE(kvStore_, nullptr);
1265     std::string str;
1266     int maxsize = 1024;
1267     for (int i = 0; i <= maxsize; i++) {
1268         str += "key";
1269     }
1270     const Key prefix(str);
1271     std::vector<Entry> output;
1272     auto status = kvStore_->GetEntries(prefix, output);
1273     ASSERT_EQ(status, INVALID_ARGUMENT);
1274 }
1275 
1276 /**
1277  * @tc.name: GetResultSetOverMaxPrefix
1278  * @tc.desc: get result set the by prefix and the prefix size  over the limits
1279  * @tc.type: FUNC
1280  * @tc.require: I605H3
1281  * @tc.author: Wang Kai
1282  */
1283 HWTEST_F(SingleStoreImplTest, GetResultSetOverMaxPrefix, TestSize.Level0)
1284 {
1285     ASSERT_NE(kvStore_, nullptr);
1286     std::string str;
1287     int maxsize = 1024;
1288     for (int i = 0; i <= maxsize; i++) {
1289         str += "key";
1290     }
1291     const Key prefix(str);
1292     std::shared_ptr<KvStoreResultSet> output;
1293     auto status = kvStore_->GetResultSet(prefix, output);
1294     ASSERT_EQ(status, INVALID_ARGUMENT);
1295 }
1296 
1297 /**
1298  * @tc.name: RemoveNullDeviceData
1299  * @tc.desc: remove local device data and the device is null
1300  * @tc.type: FUNC
1301  * @tc.require: I605H3
1302  * @tc.author: Wang Kai
1303  */
1304 HWTEST_F(SingleStoreImplTest, RemoveNullDeviceData, TestSize.Level0)
1305 {
1306     auto store = CreateKVStore("DeviceKVStore", DEVICE_COLLABORATION, false, true);
1307     ASSERT_NE(store, nullptr);
1308     std::vector<Entry> input;
__anonf1f971f10802(const Key &entry, const Key &sentry) 1309     auto cmp = [](const Key &entry, const Key &sentry) { return entry.Data() < sentry.Data(); };
1310     std::map<Key, Value, decltype(cmp)> dictionary(cmp);
1311     for (int i = 0; i < 10; ++i) {
1312         Entry entry;
1313         entry.key = std::to_string(i).append("_k");
1314         entry.value = std::to_string(i).append("_v");
1315         dictionary[entry.key] = entry.value;
1316         input.push_back(entry);
1317     }
1318     auto status = store->PutBatch(input);
1319     ASSERT_EQ(status, SUCCESS);
1320     int count = 0;
1321     status = store->GetCount({}, count);
1322     ASSERT_EQ(status, SUCCESS);
1323     ASSERT_EQ(count, 10);
1324     const string device = { "" };
1325     ChangeOwnerToService(
1326         "/data/service/el1/public/database/SingleStoreImplTest",
1327         "703c6ec99aa7226bb9f6194cdd60e1873ea9ee52faebd55657ade9f5a5cc3cbd");
1328     status = store->RemoveDeviceData(device);
1329     ASSERT_EQ(status, SUCCESS);
1330 }
1331 
1332 /**
1333  * @tc.name: CloseKVStoreWithInvalidAppId
1334  * @tc.desc: close the kv store with invalid appid
1335  * @tc.type: FUNC
1336  * @tc.require:
1337  * @tc.author: Yang Qing
1338  */
1339 HWTEST_F(SingleStoreImplTest, CloseKVStoreWithInvalidAppId, TestSize.Level0)
1340 {
1341     AppId appId = { "" };
1342     StoreId storeId = { "SingleKVStore" };
1343     Status status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1344     ASSERT_EQ(status, INVALID_ARGUMENT);
1345 }
1346 
1347 /**
1348  * @tc.name: CloseKVStoreWithInvalidStoreId
1349  * @tc.desc: close the kv store with invalid store id
1350  * @tc.type: FUNC
1351  * @tc.require:
1352  * @tc.author: Yang Qing
1353  */
1354 HWTEST_F(SingleStoreImplTest, CloseKVStoreWithInvalidStoreId, TestSize.Level0)
1355 {
1356     AppId appId = { "SingleStoreImplTest" };
1357     StoreId storeId = { "" };
1358     Status status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1359     ASSERT_EQ(status, INVALID_ARGUMENT);
1360 }
1361 
1362 /**
1363  * @tc.name: CloseAllKVStore
1364  * @tc.desc: close all kv store
1365  * @tc.type: FUNC
1366  * @tc.require:
1367  * @tc.author: Yang Qing
1368  */
1369 HWTEST_F(SingleStoreImplTest, CloseAllKVStore, TestSize.Level0)
1370 {
1371     AppId appId = { "SingleStoreImplTestCloseAll" };
1372     std::vector<std::shared_ptr<SingleKvStore>> kvStores;
1373     for (int i = 0; i < 5; i++) {
1374         std::shared_ptr<SingleKvStore> kvStore;
1375         Options options;
1376         options.kvStoreType = SINGLE_VERSION;
1377         options.securityLevel = S1;
1378         options.area = EL1;
1379         options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1380         std::string sId = "SingleStoreImplTestCloseAll" + std::to_string(i);
1381         StoreId storeId = { sId };
1382         Status status;
1383         kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1384         ASSERT_NE(kvStore, nullptr);
1385         kvStores.push_back(kvStore);
1386         ASSERT_EQ(status, SUCCESS);
1387         kvStore = nullptr;
1388     }
1389     Status status = StoreManager::GetInstance().CloseAllKVStore(appId);
1390     ASSERT_EQ(status, SUCCESS);
1391 }
1392 
1393 /**
1394  * @tc.name: CloseAllKVStoreWithInvalidAppId
1395  * @tc.desc: close the kv store with invalid appid
1396  * @tc.type: FUNC
1397  * @tc.require:
1398  * @tc.author: Yang Qing
1399  */
1400 HWTEST_F(SingleStoreImplTest, CloseAllKVStoreWithInvalidAppId, TestSize.Level0)
1401 {
1402     AppId appId = { "" };
1403     Status status = StoreManager::GetInstance().CloseAllKVStore(appId);
1404     ASSERT_EQ(status, INVALID_ARGUMENT);
1405 }
1406 
1407 /**
1408  * @tc.name: DeleteWithInvalidAppId
1409  * @tc.desc: delete the kv store with invalid appid
1410  * @tc.type: FUNC
1411  * @tc.require:
1412  * @tc.author: Yang Qing
1413  */
1414 HWTEST_F(SingleStoreImplTest, DeleteWithInvalidAppId, TestSize.Level0)
1415 {
1416     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1417     AppId appId = { "" };
1418     StoreId storeId = { "SingleKVStore" };
1419     Status status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
1420     ASSERT_EQ(status, INVALID_ARGUMENT);
1421 }
1422 
1423 /**
1424  * @tc.name: DeleteWithInvalidStoreId
1425  * @tc.desc: delete the kv store with invalid storeid
1426  * @tc.type: FUNC
1427  * @tc.require:
1428  * @tc.author: Yang Qing
1429  */
1430 HWTEST_F(SingleStoreImplTest, DeleteWithInvalidStoreId, TestSize.Level0)
1431 {
1432     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1433     AppId appId = { "SingleStoreImplTest" };
1434     StoreId storeId = { "" };
1435     Status status = StoreManager::GetInstance().Delete(appId, storeId, baseDir);
1436     ASSERT_EQ(status, INVALID_ARGUMENT);
1437 }
1438 
1439 /**
1440  * @tc.name: GetKVStoreWithPersistentFalse
1441  * @tc.desc: delete the kv store with the persistent is false
1442  * @tc.type: FUNC
1443  * @tc.require:
1444  * @tc.author: Wang Kai
1445  */
1446 HWTEST_F(SingleStoreImplTest, GetKVStoreWithPersistentFalse, TestSize.Level0)
1447 {
1448     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1449     AppId appId = { "SingleStoreImplTest" };
1450     StoreId storeId = { "SingleKVStorePersistentFalse" };
1451     std::shared_ptr<SingleKvStore> kvStore;
1452     Options options;
1453     options.kvStoreType = SINGLE_VERSION;
1454     options.securityLevel = S1;
1455     options.area = EL1;
1456     options.persistent = false;
1457     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1458     Status status;
1459     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1460     ASSERT_EQ(kvStore, nullptr);
1461 }
1462 
1463 /**
1464  * @tc.name: GetKVStoreWithInvalidType
1465  * @tc.desc: delete the kv store with the KvStoreType is InvalidType
1466  * @tc.type: FUNC
1467  * @tc.require:
1468  * @tc.author: Wang Kai
1469  */
1470 HWTEST_F(SingleStoreImplTest, GetKVStoreWithInvalidType, TestSize.Level0)
1471 {
1472     std::string baseDir = "/data/service/el1/public/database/SingleStoreImpStore";
1473     AppId appId = { "SingleStoreImplTest" };
1474     StoreId storeId = { "SingleKVStoreInvalidType" };
1475     std::shared_ptr<SingleKvStore> kvStore;
1476     Options options;
1477     options.kvStoreType = INVALID_TYPE;
1478     options.securityLevel = S1;
1479     options.area = EL1;
1480     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1481     Status status;
1482     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1483     ASSERT_EQ(kvStore, nullptr);
1484 }
1485 
1486 /**
1487  * @tc.name: GetKVStoreWithCreateIfMissingFalse
1488  * @tc.desc: delete the kv store with the createIfMissing is false
1489  * @tc.type: FUNC
1490  * @tc.require:
1491  * @tc.author: Wang Kai
1492  */
1493 HWTEST_F(SingleStoreImplTest, GetKVStoreWithCreateIfMissingFalse, TestSize.Level0)
1494 {
1495     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1496     AppId appId = { "SingleStoreImplTest" };
1497     StoreId storeId = { "SingleKVStoreCreateIfMissingFalse" };
1498     std::shared_ptr<SingleKvStore> kvStore;
1499     Options options;
1500     options.kvStoreType = SINGLE_VERSION;
1501     options.securityLevel = S1;
1502     options.area = EL1;
1503     options.createIfMissing = false;
1504     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1505     Status status;
1506     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1507     ASSERT_EQ(kvStore, nullptr);
1508 }
1509 
1510 /**
1511  * @tc.name: GetKVStoreWithAutoSync
1512  * @tc.desc: delete the kv store with the autoSync is false
1513  * @tc.type: FUNC
1514  * @tc.require:
1515  * @tc.author: Wang Kai
1516  */
1517 HWTEST_F(SingleStoreImplTest, GetKVStoreWithAutoSync, TestSize.Level0)
1518 {
1519     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1520     AppId appId = { "SingleStoreImplTest" };
1521     StoreId storeId = { "SingleKVStoreAutoSync" };
1522     std::shared_ptr<SingleKvStore> kvStore;
1523     Options options;
1524     options.kvStoreType = SINGLE_VERSION;
1525     options.securityLevel = S1;
1526     options.area = EL1;
1527     options.autoSync = false;
1528     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1529     Status status;
1530     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1531     ASSERT_NE(kvStore, nullptr);
1532     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1533     ASSERT_EQ(status, SUCCESS);
1534 }
1535 
1536 /**
1537  * @tc.name: GetKVStoreWithAreaEL2
1538  * @tc.desc: delete the kv store with the area is EL2
1539  * @tc.type: FUNC
1540  * @tc.require:
1541  * @tc.author: Wang Kai
1542  */
1543 HWTEST_F(SingleStoreImplTest, GetKVStoreWithAreaEL2, TestSize.Level0)
1544 {
1545     std::string baseDir = "/data/service/el2/100/SingleStoreImplTest";
1546     mkdir(baseDir.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
1547 
1548     AppId appId = { "SingleStoreImplTest" };
1549     StoreId storeId = { "SingleKVStoreAreaEL2" };
1550     std::shared_ptr<SingleKvStore> kvStore;
1551     Options options;
1552     options.kvStoreType = SINGLE_VERSION;
1553     options.securityLevel = S2;
1554     options.area = EL2;
1555     options.baseDir = "/data/service/el2/100/SingleStoreImplTest";
1556     Status status;
1557     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1558     ASSERT_NE(kvStore, nullptr);
1559     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1560     ASSERT_EQ(status, SUCCESS);
1561 }
1562 
1563 /**
1564  * @tc.name: GetKVStoreWithRebuildTrue
1565  * @tc.desc: delete the kv store with the rebuild is true
1566  * @tc.type: FUNC
1567  * @tc.require:
1568  * @tc.author: Wang Kai
1569  */
1570 HWTEST_F(SingleStoreImplTest, GetKVStoreWithRebuildTrue, TestSize.Level0)
1571 {
1572     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1573     AppId appId = { "SingleStoreImplTest" };
1574     StoreId storeId = { "SingleKVStoreRebuildFalse" };
1575     std::shared_ptr<SingleKvStore> kvStore;
1576     Options options;
1577     options.kvStoreType = SINGLE_VERSION;
1578     options.securityLevel = S1;
1579     options.area = EL1;
1580     options.rebuild = true;
1581     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1582     Status status;
1583     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1584     ASSERT_NE(kvStore, nullptr);
1585     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1586     ASSERT_EQ(status, SUCCESS);
1587 }
1588 
1589 /**
1590  * @tc.name: GetStaticStore
1591  * @tc.desc: get static store
1592  * @tc.type: FUNC
1593  * @tc.require:
1594  * @tc.author: zuojiangijang
1595  */
1596 HWTEST_F(SingleStoreImplTest, GetStaticStore, TestSize.Level0)
1597 {
1598     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1599     AppId appId = { "SingleStoreImplTest" };
1600     StoreId storeId = { "StaticStoreTest" };
1601     std::shared_ptr<SingleKvStore> kvStore;
1602     Options options;
1603     options.kvStoreType = SINGLE_VERSION;
1604     options.securityLevel = S1;
1605     options.area = EL1;
1606     options.rebuild = true;
1607     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1608     options.dataType = DataType::TYPE_STATICS;
1609     Status status;
1610     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1611     ASSERT_NE(kvStore, nullptr);
1612     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1613     ASSERT_EQ(status, SUCCESS);
1614 }
1615 
1616 /**
1617  * @tc.name: StaticStoreAsyncGet
1618  * @tc.desc: static store async get
1619  * @tc.type: FUNC
1620  * @tc.require:
1621  * @tc.author: zuojiangijang
1622  */
1623 HWTEST_F(SingleStoreImplTest, StaticStoreAsyncGet, TestSize.Level0)
1624 {
1625     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1626     AppId appId = { "SingleStoreImplTest" };
1627     StoreId storeId = { "StaticStoreAsyncGetTest" };
1628     std::shared_ptr<SingleKvStore> kvStore;
1629     Options options;
1630     options.kvStoreType = SINGLE_VERSION;
1631     options.securityLevel = S1;
1632     options.area = EL1;
1633     options.rebuild = true;
1634     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1635     options.dataType = DataType::TYPE_STATICS;
1636     Status status;
1637     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1638     ASSERT_NE(kvStore, nullptr);
1639     BlockData<bool> blockData{ 1, false };
__anonf1f971f10902(Status status, Value&& value) 1640     std::function<void(Status, Value&&)> result = [&blockData](Status status, Value&& value) {
1641         ASSERT_EQ(status, Status::NOT_FOUND);
1642         blockData.SetValue(true);
1643     };
1644     auto networkId = DevManager::GetInstance().GetLocalDevice().networkId;
1645     kvStore->Get({"key"}, networkId, result);
1646     blockData.GetValue();
1647     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1648     ASSERT_EQ(status, SUCCESS);
1649 }
1650 
1651 /**
1652  * @tc.name: StaticStoreAsyncGetEntries
1653  * @tc.desc: static store async get entries
1654  * @tc.type: FUNC
1655  * @tc.require:
1656  * @tc.author: zuojiangijang
1657  */
1658 HWTEST_F(SingleStoreImplTest, StaticStoreAsyncGetEntries, TestSize.Level0)
1659 {
1660     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1661     AppId appId = { "SingleStoreImplTest" };
1662     StoreId storeId = { "StaticStoreAsyncGetEntriesTest" };
1663     std::shared_ptr<SingleKvStore> kvStore;
1664     Options options;
1665     options.kvStoreType = SINGLE_VERSION;
1666     options.securityLevel = S1;
1667     options.area = EL1;
1668     options.rebuild = true;
1669     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1670     options.dataType = DataType::TYPE_STATICS;
1671     Status status;
1672     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1673     ASSERT_NE(kvStore, nullptr);
1674     BlockData<bool> blockData{ 1, false };
1675     std::function<void(Status, std::vector<Entry>&&)> result =
__anonf1f971f10a02(Status status, std::vector<Entry>&& value) 1676         [&blockData](Status status, std::vector<Entry>&& value) {
1677             ASSERT_EQ(status, Status::SUCCESS);
1678             blockData.SetValue(true);
1679     };
1680     auto networkId = DevManager::GetInstance().GetLocalDevice().networkId;
1681     kvStore->GetEntries({"key"}, networkId, result);
1682     blockData.GetValue();
1683     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1684     ASSERT_EQ(status, SUCCESS);
1685 }
1686 
1687 /**
1688  * @tc.name: DynamicStoreAsyncGet
1689  * @tc.desc: dynamic store async get
1690  * @tc.type: FUNC
1691  * @tc.require:
1692  * @tc.author: zuojiangijang
1693  */
1694 HWTEST_F(SingleStoreImplTest, DynamicStoreAsyncGet, TestSize.Level0)
1695 {
1696     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1697     AppId appId = { "SingleStoreImplTest" };
1698     StoreId storeId = { "DynamicStoreAsyncGetTest" };
1699     std::shared_ptr<SingleKvStore> kvStore;
1700     Options options;
1701     options.kvStoreType = SINGLE_VERSION;
1702     options.securityLevel = S1;
1703     options.area = EL1;
1704     options.rebuild = true;
1705     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1706     options.dataType = DataType::TYPE_DYNAMICAL;
1707     Status status;
1708     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1709     ASSERT_NE(kvStore, nullptr);
1710     status = kvStore->Put({ "Put Test" }, { "Put Value" });
1711     auto networkId = DevManager::GetInstance().GetLocalDevice().networkId;
1712     BlockData<bool> blockData{ 1, false };
__anonf1f971f10b02(Status status, Value&& value) 1713     std::function<void(Status, Value&&)> result = [&blockData](Status status, Value&& value) {
1714         ASSERT_EQ(status, Status::SUCCESS);
1715         ASSERT_EQ(value.ToString(), "Put Value");
1716         blockData.SetValue(true);
1717     };
1718     kvStore->Get({"Put Test"}, networkId, result);
1719     blockData.GetValue();
1720     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1721     ASSERT_EQ(status, SUCCESS);
1722 }
1723 
1724 /**
1725  * @tc.name: DynamicStoreAsyncGetEntries
1726  * @tc.desc: dynamic store async get entries
1727  * @tc.type: FUNC
1728  * @tc.require:
1729  * @tc.author: zuojiangijang
1730  */
1731 HWTEST_F(SingleStoreImplTest, DynamicStoreAsyncGetEntries, TestSize.Level0)
1732 {
1733     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1734     AppId appId = { "SingleStoreImplTest" };
1735     StoreId storeId = { "DynamicStoreAsyncGetEntriesTest" };
1736     std::shared_ptr<SingleKvStore> kvStore;
1737     Options options;
1738     options.kvStoreType = SINGLE_VERSION;
1739     options.securityLevel = S1;
1740     options.area = EL1;
1741     options.rebuild = true;
1742     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1743     options.dataType = DataType::TYPE_DYNAMICAL;
1744     Status status;
1745     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1746     ASSERT_NE(kvStore, nullptr);
1747     std::vector<Entry> entries;
1748     for (int i = 0; i < 10; ++i) {
1749         Entry entry;
1750         entry.key = "key_" + std::to_string(i);
1751         entry.value = std::to_string(i);
1752         entries.push_back(entry);
1753     }
1754     status = kvStore->PutBatch(entries);
1755     ASSERT_EQ(status, SUCCESS);
1756     auto networkId = DevManager::GetInstance().GetLocalDevice().networkId;
1757     BlockData<bool> blockData{ 1, false };
1758     std::function<void(Status, std::vector<Entry>&&)> result =
__anonf1f971f10c02(Status status, std::vector<Entry>&& value) 1759         [entries, &blockData](Status status, std::vector<Entry>&& value) {
1760             ASSERT_EQ(status, Status::SUCCESS);
1761             ASSERT_EQ(value.size(), entries.size());
1762             blockData.SetValue(true);
1763     };
1764     kvStore->GetEntries({"key_"}, networkId, result);
1765     blockData.GetValue();
1766     status = StoreManager::GetInstance().CloseKVStore(appId, storeId);
1767     ASSERT_EQ(status, SUCCESS);
1768 }
1769 
1770 /**
1771  * @tc.name: SetConfig
1772  * @tc.desc: SetConfig
1773  * @tc.type: FUNC
1774  * @tc.require:
1775  * @tc.author: ht
1776  */
1777 HWTEST_F(SingleStoreImplTest, SetConfig, TestSize.Level0)
1778 {
1779     std::string baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1780     AppId appId = { "SingleStoreImplTest" };
1781     StoreId storeId = { "SetConfigTest" };
1782     std::shared_ptr<SingleKvStore> kvStore;
1783     Options options;
1784     options.kvStoreType = SINGLE_VERSION;
1785     options.securityLevel = S1;
1786     options.area = EL1;
1787     options.rebuild = true;
1788     options.baseDir = "/data/service/el1/public/database/SingleStoreImplTest";
1789     options.dataType = DataType::TYPE_DYNAMICAL;
1790     options.cloudConfig.enableCloud = false;
1791     Status status;
1792     kvStore = StoreManager::GetInstance().GetKVStore(appId, storeId, options, status);
1793     ASSERT_NE(kvStore, nullptr);
1794     StoreConfig storeConfig;
1795     storeConfig.cloudConfig.enableCloud = true;
1796     ASSERT_EQ(kvStore->SetConfig(storeConfig), Status::SUCCESS);
1797 }
1798 } // namespace OHOS::Test