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