1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #define LOG_TAG "LocalSubscribeStoreTest"
17 #include <cstdint>
18 #include <gtest/gtest.h>
19 #include <mutex>
20 #include <vector>
21 #include "block_data.h"
22 #include "distributed_kv_data_manager.h"
23 #include "log_print.h"
24 #include "types.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::DistributedKv;
28 using namespace OHOS;
29 class LocalSubscribeStoreTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35
36 static DistributedKvDataManager manager;
37 static std::shared_ptr<SingleKvStore> kvStore;
38 static Status statusGetKvStore;
39 static AppId appId;
40 static StoreId storeId;
41 };
42 std::shared_ptr<SingleKvStore> LocalSubscribeStoreTest::kvStore = nullptr;
43 Status LocalSubscribeStoreTest::statusGetKvStore = Status::ERROR;
44 DistributedKvDataManager LocalSubscribeStoreTest::manager;
45 AppId LocalSubscribeStoreTest::appId;
46 StoreId LocalSubscribeStoreTest::storeId;
47
SetUpTestCase(void)48 void LocalSubscribeStoreTest::SetUpTestCase(void)
49 {
50 mkdir("/data/service/el1/public/database/odmf", (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
51 }
52
TearDownTestCase(void)53 void LocalSubscribeStoreTest::TearDownTestCase(void)
54 {
55 manager.CloseKvStore(appId, kvStore);
56 kvStore = nullptr;
57 manager.DeleteKvStore(appId, storeId, "/data/service/el1/public/database/odmf");
58 (void)remove("/data/service/el1/public/database/odmf/kvdb");
59 (void)remove("/data/service/el1/public/database/odmf");
60 }
61
SetUp(void)62 void LocalSubscribeStoreTest::SetUp(void)
63 {
64 Options options;
65 options.createIfMissing = true;
66 options.encrypt = false; // not supported yet.
67 options.securityLevel = S1;
68 options.autoSync = true; // not supported yet.
69 options.kvStoreType = KvStoreType::SINGLE_VERSION;
70 options.area = EL1;
71 options.baseDir = std::string("/data/service/el1/public/database/odmf");
72 appId.appId = "odmf"; // define app name.
73 storeId.storeId = "student"; // define kvstore(database) name
74 manager.DeleteKvStore(appId, storeId, options.baseDir);
75 // [create and] open and initialize kvstore instance.
76 statusGetKvStore = manager.GetSingleKvStore(options, appId, storeId, kvStore);
77 EXPECT_EQ(Status::SUCCESS, statusGetKvStore) << "statusGetKvStore return wrong status";
78 EXPECT_NE(nullptr, kvStore) << "kvStore is nullptr";
79 }
80
TearDown(void)81 void LocalSubscribeStoreTest::TearDown(void)
82 {
83 manager.CloseKvStore(appId, kvStore);
84 kvStore = nullptr;
85 manager.DeleteKvStore(appId, storeId);
86 }
87
88 class KvStoreObserverUnitTest : public KvStoreObserver {
89 public:
90 std::vector<Entry> insertEntries_;
91 std::vector<Entry> updateEntries_;
92 std::vector<Entry> deleteEntries_;
93 bool isClear_ = false;
94 KvStoreObserverUnitTest();
~KvStoreObserverUnitTest()95 ~KvStoreObserverUnitTest()
96 {}
97
98 KvStoreObserverUnitTest(const KvStoreObserverUnitTest &) = delete;
99 KvStoreObserverUnitTest &operator=(const KvStoreObserverUnitTest &) = delete;
100 KvStoreObserverUnitTest(KvStoreObserverUnitTest &&) = delete;
101 KvStoreObserverUnitTest &operator=(KvStoreObserverUnitTest &&) = delete;
102
103 void OnChange(const ChangeNotification &changeNotification);
104
105 // reset the callCount_ to zero.
106 void ResetToZero();
107
108 uint32_t GetCallCount(uint32_t value = 1);
109
110 private:
111 std::mutex mutex_;
112 uint32_t callCount_ = 0;
113 BlockData<uint32_t> value_{ 1, 0 };
114 };
115
KvStoreObserverUnitTest()116 KvStoreObserverUnitTest::KvStoreObserverUnitTest()
117 {
118 }
119
OnChange(const ChangeNotification & changeNotification)120 void KvStoreObserverUnitTest::OnChange(const ChangeNotification &changeNotification)
121 {
122 ZLOGD("begin.");
123 insertEntries_ = changeNotification.GetInsertEntries();
124 updateEntries_ = changeNotification.GetUpdateEntries();
125 deleteEntries_ = changeNotification.GetDeleteEntries();
126 changeNotification.GetDeviceId();
127 isClear_ = changeNotification.IsClear();
128 std::lock_guard<decltype(mutex_)> guard(mutex_);
129 ++callCount_;
130 value_.SetValue(callCount_);
131 }
132
ResetToZero()133 void KvStoreObserverUnitTest::ResetToZero()
134 {
135 std::lock_guard<decltype(mutex_)> guard(mutex_);
136 callCount_ = 0;
137 value_.Clear(0);
138 }
139
GetCallCount(uint32_t value)140 uint32_t KvStoreObserverUnitTest::GetCallCount(uint32_t value)
141 {
142 int retry = 0;
143 uint32_t callTimes = 0;
144 while (retry < value) {
145 callTimes = value_.GetValue();
146 if (callTimes >= value) {
147 break;
148 }
149 std::lock_guard<decltype(mutex_)> guard(mutex_);
150 callTimes = value_.GetValue();
151 if (callTimes >= value) {
152 break;
153 }
154 value_.Clear(callTimes);
155 retry++;
156 }
157 return callTimes;
158 }
159
160 /**
161 * @tc.name: KvStoreDdmSubscribeKvStore001
162 * @tc.desc: Subscribe success
163 * @tc.type: FUNC
164 * @tc.require: AR000CQDU9 AR000CQS37
165 * @tc.author: liuyuhui
166 */
167 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore001, TestSize.Level1)
168 {
169 ZLOGI("KvStoreDdmSubscribeKvStore001 begin.");
170 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
171 auto observer = std::make_shared<KvStoreObserverUnitTest>();
172 observer->ResetToZero();
173
174 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
175 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
176 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 0);
177
178 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
179 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
180 observer = nullptr;
181 }
182
183 /**
184 * @tc.name: KvStoreDdmSubscribeKvStore002
185 * @tc.desc: Subscribe fail, observer is null
186 * @tc.type: FUNC
187 * @tc.require: AR000CQDU9 AR000CQS37
188 * @tc.author: liuyuhui
189 */
190 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore002, TestSize.Level1)
191 {
192 ZLOGI("KvStoreDdmSubscribeKvStore002 begin.");
193 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
194 std::shared_ptr<KvStoreObserverUnitTest> observer = nullptr;
195 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
196 EXPECT_EQ(Status::INVALID_ARGUMENT, status) << "SubscribeKvStore return wrong status";
197 }
198
199 /**
200 * @tc.name: KvStoreDdmSubscribeKvStore003
201 * @tc.desc: Subscribe success and OnChange callback after put
202 * @tc.type: FUNC
203 * @tc.require: AR000CQDU9 AR000CQS37
204 * @tc.author: liuyuhui
205 */
206 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore003, TestSize.Level1)
207 {
208 ZLOGI("KvStoreDdmSubscribeKvStore003 begin.");
209 auto observer = std::make_shared<KvStoreObserverUnitTest>();
210
211 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
212 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
213 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
214
215 Key key = "Id1";
216 Value value = "subscribe";
217 status = kvStore->Put(key, value); // insert or update key-value
218 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
219 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
220
221 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
222 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
223 observer = nullptr;
224 }
225
226 /**
227 * @tc.name: KvStoreDdmSubscribeKvStore004
228 * @tc.desc: The same observer subscribe three times and OnChange callback after put
229 * @tc.type: FUNC
230 * @tc.require: AR000CQDU9 AR000CQS37
231 * @tc.author: liuyuhui
232 */
233 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore004, TestSize.Level2)
234 {
235 ZLOGI("KvStoreDdmSubscribeKvStore004 begin.");
236 auto observer = std::make_shared<KvStoreObserverUnitTest>();
237 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
238 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
239 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
240 status = kvStore->SubscribeKvStore(subscribeType, observer);
241 EXPECT_EQ(Status::STORE_ALREADY_SUBSCRIBE, status) << "SubscribeKvStore return wrong status";
242 status = kvStore->SubscribeKvStore(subscribeType, observer);
243 EXPECT_EQ(Status::STORE_ALREADY_SUBSCRIBE, status) << "SubscribeKvStore return wrong status";
244
245 Key key = "Id1";
246 Value value = "subscribe";
247 status = kvStore->Put(key, value); // insert or update key-value
248 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
249 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
250
251 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
252 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
253 }
254
255 /**
256 * @tc.name: KvStoreDdmSubscribeKvStore005
257 * @tc.desc: The different observer subscribe three times and OnChange callback after put
258 * @tc.type: FUNC
259 * @tc.require: AR000CQDU9 AR000CQS37
260 * @tc.author: liuyuhui
261 */
262 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore005, TestSize.Level2)
263 {
264 ZLOGI("KvStoreDdmSubscribeKvStore005 begin.");
265 auto observer1 = std::make_shared<KvStoreObserverUnitTest>();
266 auto observer2 = std::make_shared<KvStoreObserverUnitTest>();
267 auto observer3 = std::make_shared<KvStoreObserverUnitTest>();
268 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
269 Status status = kvStore->SubscribeKvStore(subscribeType, observer1);
270 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore failed, wrong status";
271 status = kvStore->SubscribeKvStore(subscribeType, observer2);
272 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore failed, wrong status";
273 status = kvStore->SubscribeKvStore(subscribeType, observer3);
274 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore failed, wrong status";
275
276 Key key = "Id1";
277 Value value = "subscribe";
278 status = kvStore->Put(key, value); // insert or update key-value
279 EXPECT_EQ(Status::SUCCESS, status) << "Putting data to KvStore failed, wrong status";
280 EXPECT_EQ(static_cast<int>(observer1->GetCallCount()), 1);
281 EXPECT_EQ(static_cast<int>(observer2->GetCallCount()), 1);
282 EXPECT_EQ(static_cast<int>(observer3->GetCallCount()), 1);
283
284 status = kvStore->UnSubscribeKvStore(subscribeType, observer1);
285 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
286 status = kvStore->UnSubscribeKvStore(subscribeType, observer2);
287 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
288 status = kvStore->UnSubscribeKvStore(subscribeType, observer3);
289 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
290 }
291
292 /**
293 * @tc.name: KvStoreDdmSubscribeKvStore006
294 * @tc.desc: Unsubscribe an observer and subscribe again - the map should be cleared after unsubscription.
295 * @tc.type: FUNC
296 * @tc.require: AR000CQDU9 AR000CQS37
297 * @tc.author: liuyuhui
298 */
299 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore006, TestSize.Level2)
300 {
301 ZLOGI("KvStoreDdmSubscribeKvStore006 begin.");
302 auto observer = std::make_shared<KvStoreObserverUnitTest>();
303 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
304 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
305 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
306
307 Key key1 = "Id1";
308 Value value1 = "subscribe";
309 status = kvStore->Put(key1, value1); // insert or update key-value
310 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
311 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
312
313 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
314 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
315
316 Key key2 = "Id2";
317 Value value2 = "subscribe";
318 status = kvStore->Put(key2, value2); // insert or update key-value
319 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
320 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
321
322 kvStore->SubscribeKvStore(subscribeType, observer);
323 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
324 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
325 Key key3 = "Id3";
326 Value value3 = "subscribe";
327 status = kvStore->Put(key3, value3); // insert or update key-value
328 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
329 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
330
331 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
332 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
333 }
334
335 /**
336 * @tc.name: KvStoreDdmSubscribeKvStore007
337 * @tc.desc: Subscribe to an observer - OnChange callback is called multiple times after the put operation.
338 * @tc.type: FUNC
339 * @tc.require: AR000CQDU9 AR000CQS37
340 * @tc.author: liuyuhui
341 */
342 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore007, TestSize.Level2)
343 {
344 ZLOGI("KvStoreDdmSubscribeKvStore007 begin.");
345 auto observer = std::make_shared<KvStoreObserverUnitTest>();
346 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
347 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
348 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
349
350 Key key1 = "Id1";
351 Value value1 = "subscribe";
352 status = kvStore->Put(key1, value1); // insert or update key-value
353 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
354
355 Key key2 = "Id2";
356 Value value2 = "subscribe";
357 status = kvStore->Put(key2, value2); // insert or update key-value
358 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
359
360 Key key3 = "Id3";
361 Value value3 = "subscribe";
362 status = kvStore->Put(key3, value3); // insert or update key-value
363 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
364 EXPECT_EQ(static_cast<int>(observer->GetCallCount(3)), 3);
365
366 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
367 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
368 }
369
370 /**
371 * @tc.name: KvStoreDdmSubscribeKvStore008
372 * @tc.desc: Subscribe to an observer - OnChange callback is called multiple times after the put&update operations.
373 * @tc.type: FUNC
374 * @tc.require: AR000CQDU9 AR000CQS37
375 * @tc.author: liuyuhui
376 */
377 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore008, TestSize.Level2)
378 {
379 ZLOGI("KvStoreDdmSubscribeKvStore008 begin.");
380 auto observer = std::make_shared<KvStoreObserverUnitTest>();
381 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
382 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
383 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
384
385 Key key1 = "Id1";
386 Value value1 = "subscribe";
387 status = kvStore->Put(key1, value1); // insert or update key-value
388 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
389
390 Key key2 = "Id2";
391 Value value2 = "subscribe";
392 status = kvStore->Put(key2, value2); // insert or update key-value
393 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
394
395 Key key3 = "Id1";
396 Value value3 = "subscribe03";
397 status = kvStore->Put(key3, value3); // insert or update key-value
398 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
399 EXPECT_EQ(static_cast<int>(observer->GetCallCount(3)), 3);
400 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
401 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
402 }
403
404 /**
405 * @tc.name: KvStoreDdmSubscribeKvStore009
406 * @tc.desc: Subscribe to an observer - OnChange callback is called multiple times after the putBatch operation.
407 * @tc.type: FUNC
408 * @tc.require: AR000CQDU9 AR000CQS37
409 * @tc.author: liuyuhui
410 */
411 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore009, TestSize.Level2)
412 {
413 ZLOGI("KvStoreDdmSubscribeKvStore009 begin.");
414 auto observer = std::make_shared<KvStoreObserverUnitTest>();
415 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
416 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
417 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
418
419 // before update.
420 std::vector<Entry> entries1;
421 Entry entry1, entry2, entry3;
422 entry1.key = "Id1";
423 entry1.value = "subscribe";
424 entry2.key = "Id2";
425 entry2.value = "subscribe";
426 entry3.key = "Id3";
427 entry3.value = "subscribe";
428 entries1.push_back(entry1);
429 entries1.push_back(entry2);
430 entries1.push_back(entry3);
431
432 std::vector<Entry> entries2;
433 Entry entry4, entry5;
434 entry4.key = "Id4";
435 entry4.value = "subscribe";
436 entry5.key = "Id5";
437 entry5.value = "subscribe";
438 entries2.push_back(entry4);
439 entries2.push_back(entry5);
440
441 status = kvStore->PutBatch(entries1);
442 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
443 status = kvStore->PutBatch(entries2);
444 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
445 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
446
447 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
448 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
449 }
450
451 /**
452 * @tc.name: KvStoreDdmSubscribeKvStore010
453 * @tc.desc: Subscribe to an observer - OnChange callback is called multiple times after the putBatch update operation.
454 * @tc.type: FUNC
455 * @tc.require: AR000CQDU9 AR000CQS37
456 * @tc.author: liuyuhui
457 */
458 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore010, TestSize.Level2)
459 {
460 ZLOGI("KvStoreDdmSubscribeKvStore010 begin.");
461 auto observer = std::make_shared<KvStoreObserverUnitTest>();
462 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
463 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
464 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
465
466 // before update.
467 std::vector<Entry> entries1;
468 Entry entry1, entry2, entry3;
469 entry1.key = "Id1";
470 entry1.value = "subscribe";
471 entry2.key = "Id2";
472 entry2.value = "subscribe";
473 entry3.key = "Id3";
474 entry3.value = "subscribe";
475 entries1.push_back(entry1);
476 entries1.push_back(entry2);
477 entries1.push_back(entry3);
478
479 std::vector<Entry> entries2;
480 Entry entry4, entry5;
481 entry4.key = "Id1";
482 entry4.value = "modify";
483 entry5.key = "Id2";
484 entry5.value = "modify";
485 entries2.push_back(entry4);
486 entries2.push_back(entry5);
487
488 status = kvStore->PutBatch(entries1);
489 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
490 status = kvStore->PutBatch(entries2);
491 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
492 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
493
494 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
495 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
496 }
497
498 /**
499 * @tc.name: KvStoreDdmSubscribeKvStore011
500 * @tc.desc: Subscribe to an observer - OnChange callback is called after successful deletion.
501 * @tc.type: FUNC
502 * @tc.require: AR000CQDU9 AR000CQS37
503 * @tc.author: liuyuhui
504 */
505 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore011, TestSize.Level2)
506 {
507 ZLOGI("KvStoreDdmSubscribeKvStore011 begin.");
508 auto observer = std::make_shared<KvStoreObserverUnitTest>();
509 std::vector<Entry> entries;
510 Entry entry1, entry2, entry3;
511 entry1.key = "Id1";
512 entry1.value = "subscribe";
513 entry2.key = "Id2";
514 entry2.value = "subscribe";
515 entry3.key = "Id3";
516 entry3.value = "subscribe";
517 entries.push_back(entry1);
518 entries.push_back(entry2);
519 entries.push_back(entry3);
520
521 Status status = kvStore->PutBatch(entries);
522 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
523
524 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
525 status = kvStore->SubscribeKvStore(subscribeType, observer);
526 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
527 status = kvStore->Delete("Id1");
528 EXPECT_EQ(Status::SUCCESS, status) << "KvStore Delete data return wrong status";
529 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
530
531 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
532 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
533 }
534
535 /**
536 * @tc.name: KvStoreDdmSubscribeKvStore012
537 * @tc.desc: Subscribe to an observer - OnChange callback is not called after deletion of non-existing keys.
538 * @tc.type: FUNC
539 * @tc.require: AR000CQDU9 AR000CQS37
540 * @tc.author: liuyuhui
541 */
542 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore012, TestSize.Level2)
543 {
544 ZLOGI("KvStoreDdmSubscribeKvStore012 begin.");
545 auto observer = std::make_shared<KvStoreObserverUnitTest>();
546 std::vector<Entry> entries;
547 Entry entry1, entry2, entry3;
548 entry1.key = "Id1";
549 entry1.value = "subscribe";
550 entry2.key = "Id2";
551 entry2.value = "subscribe";
552 entry3.key = "Id3";
553 entry3.value = "subscribe";
554 entries.push_back(entry1);
555 entries.push_back(entry2);
556 entries.push_back(entry3);
557
558 Status status = kvStore->PutBatch(entries);
559 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
560
561 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
562 status = kvStore->SubscribeKvStore(subscribeType, observer);
563 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
564 status = kvStore->Delete("Id4");
565 EXPECT_EQ(Status::SUCCESS, status) << "KvStore Delete data return wrong status";
566 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 0);
567
568 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
569 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
570 }
571
572 /**
573 * @tc.name: KvStoreDdmSubscribeKvStore013
574 * @tc.desc: Subscribe to an observer - OnChange callback is called after KvStore is cleared.
575 * @tc.type: FUNC
576 * @tc.require: AR000CQDU9 AR000CQS37
577 * @tc.author: liuyuhui
578 */
579 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore013, TestSize.Level2)
580 {
581 ZLOGI("KvStoreDdmSubscribeKvStore013 begin.");
582 auto observer = std::make_shared<KvStoreObserverUnitTest>();
583 std::vector<Entry> entries;
584 Entry entry1, entry2, entry3;
585 entry1.key = "Id1";
586 entry1.value = "subscribe";
587 entry2.key = "Id2";
588 entry2.value = "subscribe";
589 entry3.key = "Id3";
590 entry3.value = "subscribe";
591 entries.push_back(entry1);
592 entries.push_back(entry2);
593 entries.push_back(entry3);
594
595 Status status = kvStore->PutBatch(entries);
596 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
597
598 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
599 status = kvStore->SubscribeKvStore(subscribeType, observer);
600 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
601 EXPECT_EQ(static_cast<int>(observer->GetCallCount(1)), 0);
602
603 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
604 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
605 }
606
607 /**
608 * @tc.name: KvStoreDdmSubscribeKvStore014
609 * @tc.desc: Subscribe to an observer - OnChange callback is not called after non-existing data in KvStore is cleared.
610 * @tc.type: FUNC
611 * @tc.require: AR000CQDU9 AR000CQS37
612 * @tc.author: liuyuhui
613 */
614 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore014, TestSize.Level2)
615 {
616 ZLOGI("KvStoreDdmSubscribeKvStore014 begin.");
617 auto observer = std::make_shared<KvStoreObserverUnitTest>();
618 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
619 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
620 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
621 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 0);
622
623 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
624 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
625 }
626
627 /**
628 * @tc.name: KvStoreDdmSubscribeKvStore015
629 * @tc.desc: Subscribe to an observer - OnChange callback is called after the deleteBatch operation.
630 * @tc.type: FUNC
631 * @tc.require: AR000CQDU9 AR000CQS37
632 * @tc.author: liuyuhui
633 */
634 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore015, TestSize.Level2)
635 {
636 ZLOGI("KvStoreDdmSubscribeKvStore015 begin.");
637 auto observer = std::make_shared<KvStoreObserverUnitTest>();
638 std::vector<Entry> entries;
639 Entry entry1, entry2, entry3;
640 entry1.key = "Id1";
641 entry1.value = "subscribe";
642 entry2.key = "Id2";
643 entry2.value = "subscribe";
644 entry3.key = "Id3";
645 entry3.value = "subscribe";
646 entries.push_back(entry1);
647 entries.push_back(entry2);
648 entries.push_back(entry3);
649
650 std::vector<Key> keys;
651 keys.push_back("Id1");
652 keys.push_back("Id2");
653
654 Status status = kvStore->PutBatch(entries);
655 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
656
657 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
658 status = kvStore->SubscribeKvStore(subscribeType, observer);
659 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
660
661 status = kvStore->DeleteBatch(keys);
662 EXPECT_EQ(Status::SUCCESS, status) << "KvStore DeleteBatch data return wrong status";
663 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
664
665 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
666 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
667 }
668
669 /**
670 * @tc.name: KvStoreDdmSubscribeKvStore016
671 * @tc.desc: Subscribe to an observer - OnChange callback is called after deleteBatch of non-existing keys.
672 * @tc.type: FUNC
673 * @tc.require: AR000CQDU9 AR000CQS37
674 * @tc.author: liuyuhui
675 */
676 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore016, TestSize.Level2)
677 {
678 ZLOGI("KvStoreDdmSubscribeKvStore016 begin.");
679 auto observer = std::make_shared<KvStoreObserverUnitTest>();
680 std::vector<Entry> entries;
681 Entry entry1, entry2, entry3;
682 entry1.key = "Id1";
683 entry1.value = "subscribe";
684 entry2.key = "Id2";
685 entry2.value = "subscribe";
686 entry3.key = "Id3";
687 entry3.value = "subscribe";
688 entries.push_back(entry1);
689 entries.push_back(entry2);
690 entries.push_back(entry3);
691
692 std::vector<Key> keys;
693 keys.push_back("Id4");
694 keys.push_back("Id5");
695
696 Status status = kvStore->PutBatch(entries);
697 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
698
699 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
700 status = kvStore->SubscribeKvStore(subscribeType, observer);
701 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
702
703 status = kvStore->DeleteBatch(keys);
704 EXPECT_EQ(Status::SUCCESS, status) << "KvStore DeleteBatch data return wrong status";
705 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 0);
706
707 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
708 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
709 }
710
711 /**
712 * @tc.name: KvStoreDdmSubscribeKvStore020
713 * @tc.desc: Unsubscribe an observer two times.
714 * @tc.type: FUNC
715 * @tc.require: AR000CQDU9 AR000CQS37
716 * @tc.author: liuyuhui
717 */
718 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStore020, TestSize.Level2)
719 {
720 ZLOGI("KvStoreDdmSubscribeKvStore020 begin.");
721 auto observer = std::make_shared<KvStoreObserverUnitTest>();
722 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
723 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
724 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
725
726 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
727 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
728 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
729 EXPECT_EQ(Status::STORE_NOT_SUBSCRIBE, status) << "UnSubscribeKvStore return wrong status";
730 }
731
732 /**
733 * @tc.name: KvStoreDdmSubscribeKvStoreNotification001
734 * @tc.desc: Subscribe to an observer successfully - callback is called with a notification after the put operation.
735 * @tc.type: FUNC
736 * @tc.require: AR000CIFGM
737 * @tc.author: liuyuhui
738 */
739 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification001, TestSize.Level1)
740 {
741 ZLOGI("KvStoreDdmSubscribeKvStoreNotification001 begin.");
742 auto observer = std::make_shared<KvStoreObserverUnitTest>();
743 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
744 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
745 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
746
747 Key key = "Id1";
748 Value value = "subscribe";
749 status = kvStore->Put(key, value); // insert or update key-value
750 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
751 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
752 ZLOGD("kvstore_ddm_subscribekvstore_003");
753 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
754 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
755 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
756 ZLOGD("kvstore_ddm_subscribekvstore_003 size:%zu.", observer->insertEntries_.size());
757
758 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
759 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
760 }
761
762 /**
763 * @tc.name: KvStoreDdmSubscribeKvStoreNotification002
764 * @tc.desc: Subscribe to the same observer three times - callback is called with a notification after the put operation.
765 * @tc.type: FUNC
766 * @tc.require: AR000CIFGM
767 * @tc.author: liuyuhui
768 */
769 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification002, TestSize.Level2)
770 {
771 ZLOGI("KvStoreDdmSubscribeKvStoreNotification002 begin.");
772 auto observer = std::make_shared<KvStoreObserverUnitTest>();
773 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
774 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
775 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
776 status = kvStore->SubscribeKvStore(subscribeType, observer);
777 EXPECT_EQ(Status::STORE_ALREADY_SUBSCRIBE, status) << "SubscribeKvStore return wrong status";
778 status = kvStore->SubscribeKvStore(subscribeType, observer);
779 EXPECT_EQ(Status::STORE_ALREADY_SUBSCRIBE, status) << "SubscribeKvStore return wrong status";
780
781 Key key = "Id1";
782 Value value = "subscribe";
783 status = kvStore->Put(key, value); // insert or update key-value
784 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
785 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
786 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
787 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
788 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
789
790 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
791 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
792 }
793
794 /**
795 * @tc.name: KvStoreDdmSubscribeKvStoreNotification003
796 * @tc.desc: The different observer subscribe three times and callback with notification after put
797 * @tc.type: FUNC
798 * @tc.require: AR000CIFGM
799 * @tc.author: liuyuhui
800 */
801 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification003, TestSize.Level2)
802 {
803 ZLOGI("KvStoreDdmSubscribeKvStoreNotification003 begin.");
804 auto observer1 = std::make_shared<KvStoreObserverUnitTest>();
805 auto observer2 = std::make_shared<KvStoreObserverUnitTest>();
806 auto observer3 = std::make_shared<KvStoreObserverUnitTest>();
807 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
808 Status status = kvStore->SubscribeKvStore(subscribeType, observer1);
809 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
810 status = kvStore->SubscribeKvStore(subscribeType, observer2);
811 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
812 status = kvStore->SubscribeKvStore(subscribeType, observer3);
813 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
814
815 Key key = "Id1";
816 Value value = "subscribe";
817 status = kvStore->Put(key, value); // insert or update key-value
818 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
819 EXPECT_EQ(static_cast<int>(observer1->GetCallCount()), 1);
820 EXPECT_EQ(static_cast<int>(observer1->insertEntries_.size()), 1);
821 EXPECT_EQ("Id1", observer1->insertEntries_[0].key.ToString());
822 EXPECT_EQ("subscribe", observer1->insertEntries_[0].value.ToString());
823
824 EXPECT_EQ(static_cast<int>(observer2->GetCallCount()), 1);
825 EXPECT_EQ(static_cast<int>(observer2->insertEntries_.size()), 1);
826 EXPECT_EQ("Id1", observer2->insertEntries_[0].key.ToString());
827 EXPECT_EQ("subscribe", observer2->insertEntries_[0].value.ToString());
828
829 EXPECT_EQ(static_cast<int>(observer3->GetCallCount()), 1);
830 EXPECT_EQ(static_cast<int>(observer3->insertEntries_.size()), 1);
831 EXPECT_EQ("Id1", observer3->insertEntries_[0].key.ToString());
832 EXPECT_EQ("subscribe", observer3->insertEntries_[0].value.ToString());
833
834 status = kvStore->UnSubscribeKvStore(subscribeType, observer1);
835 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
836 status = kvStore->UnSubscribeKvStore(subscribeType, observer2);
837 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
838 status = kvStore->UnSubscribeKvStore(subscribeType, observer3);
839 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
840 }
841
842 /**
843 * @tc.name: KvStoreDdmSubscribeKvStoreNotification004
844 * @tc.desc: Verify notification after an observer is unsubscribed and then subscribed again.
845 * @tc.type: FUNC
846 * @tc.require: AR000CIFGM
847 * @tc.author: liuyuhui
848 */
849 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification004, TestSize.Level2)
850 {
851 ZLOGI("KvStoreDdmSubscribeKvStoreNotification004 begin.");
852 auto observer = std::make_shared<KvStoreObserverUnitTest>();
853 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
854 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
855 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
856
857 Key key1 = "Id1";
858 Value value1 = "subscribe";
859 status = kvStore->Put(key1, value1); // insert or update key-value
860 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
861 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
862 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
863 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
864 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
865
866 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
867 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
868
869 Key key2 = "Id2";
870 Value value2 = "subscribe";
871 status = kvStore->Put(key2, value2); // insert or update key-value
872 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
873 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
874 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
875 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
876 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
877
878 kvStore->SubscribeKvStore(subscribeType, observer);
879 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
880 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
881 Key key3 = "Id3";
882 Value value3 = "subscribe";
883 status = kvStore->Put(key3, value3); // insert or update key-value
884 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
885 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
886 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
887 EXPECT_EQ("Id3", observer->insertEntries_[0].key.ToString());
888 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
889
890 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
891 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
892 }
893
894 /**
895 * @tc.name: KvStoreDdmSubscribeKvStoreNotification005
896 * @tc.desc: Subscribe to an observer, callback with notification many times after put the different data
897 * @tc.type: FUNC
898 * @tc.require: AR000CIFGM
899 * @tc.author: liuyuhui
900 */
901 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification005, TestSize.Level2)
902 {
903 ZLOGI("KvStoreDdmSubscribeKvStoreNotification005 begin.");
904 auto observer = std::make_shared<KvStoreObserverUnitTest>();
905 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
906 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
907 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
908
909 Key key1 = "Id1";
910 Value value1 = "subscribe";
911 status = kvStore->Put(key1, value1); // insert or update key-value
912 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
913 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
914 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
915 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
916 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
917
918 Key key2 = "Id2";
919 Value value2 = "subscribe";
920 status = kvStore->Put(key2, value2); // insert or update key-value
921 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
922 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
923 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
924 EXPECT_EQ("Id2", observer->insertEntries_[0].key.ToString());
925 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
926
927 Key key3 = "Id3";
928 Value value3 = "subscribe";
929 status = kvStore->Put(key3, value3); // insert or update key-value
930 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
931 EXPECT_EQ(static_cast<int>(observer->GetCallCount(3)), 3);
932 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
933 EXPECT_EQ("Id3", observer->insertEntries_[0].key.ToString());
934 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
935
936 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
937 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
938 }
939
940 /**
941 * @tc.name: KvStoreDdmSubscribeKvStoreNotification006
942 * @tc.desc: Subscribe to an observer, callback with notification many times after put the same data
943 * @tc.type: FUNC
944 * @tc.require: AR000CIFGM
945 * @tc.author: liuyuhui
946 */
947 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification006, TestSize.Level2)
948 {
949 ZLOGI("KvStoreDdmSubscribeKvStoreNotification006 begin.");
950 auto observer = std::make_shared<KvStoreObserverUnitTest>();
951 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
952 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
953 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
954
955 Key key1 = "Id1";
956 Value value1 = "subscribe";
957 status = kvStore->Put(key1, value1); // insert or update key-value
958 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
959 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
960 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
961 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
962 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
963
964 Key key2 = "Id1";
965 Value value2 = "subscribe";
966 status = kvStore->Put(key2, value2); // insert or update key-value
967 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
968 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
969 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 1);
970 EXPECT_EQ("Id1", observer->updateEntries_[0].key.ToString());
971 EXPECT_EQ("subscribe", observer->updateEntries_[0].value.ToString());
972
973 Key key3 = "Id1";
974 Value value3 = "subscribe";
975 status = kvStore->Put(key3, value3); // insert or update key-value
976 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
977 EXPECT_EQ(static_cast<int>(observer->GetCallCount(3)), 3);
978 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 1);
979 EXPECT_EQ("Id1", observer->updateEntries_[0].key.ToString());
980 EXPECT_EQ("subscribe", observer->updateEntries_[0].value.ToString());
981
982 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
983 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
984 }
985
986 /**
987 * @tc.name: KvStoreDdmSubscribeKvStoreNotification007
988 * @tc.desc: Subscribe to an observer, callback with notification many times after put&update
989 * @tc.type: FUNC
990 * @tc.require: AR000CIFGM
991 * @tc.author: liuyuhui
992 */
993 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification007, TestSize.Level2)
994 {
995 ZLOGI("KvStoreDdmSubscribeKvStoreNotification007 begin.");
996 auto observer = std::make_shared<KvStoreObserverUnitTest>();
997 Key key1 = "Id1";
998 Value value1 = "subscribe";
999 Status status = kvStore->Put(key1, value1); // insert or update key-value
1000 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
1001
1002 Key key2 = "Id2";
1003 Value value2 = "subscribe";
1004 status = kvStore->Put(key2, value2); // insert or update key-value
1005 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
1006
1007 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1008 status = kvStore->SubscribeKvStore(subscribeType, observer);
1009 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1010
1011 Key key3 = "Id1";
1012 Value value3 = "subscribe03";
1013 status = kvStore->Put(key3, value3); // insert or update key-value
1014 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
1015
1016 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1017 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 1);
1018 EXPECT_EQ("Id1", observer->updateEntries_[0].key.ToString());
1019 EXPECT_EQ("subscribe03", observer->updateEntries_[0].value.ToString());
1020
1021 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1022 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1023 }
1024
1025 /**
1026 * @tc.name: KvStoreDdmSubscribeKvStoreNotification008
1027 * @tc.desc: Subscribe to an observer, callback with notification one times after putbatch&update
1028 * @tc.type: FUNC
1029 * @tc.require: AR000CIFGM
1030 * @tc.author: liuyuhui
1031 */
1032 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification008, TestSize.Level2)
1033 {
1034 ZLOGI("KvStoreDdmSubscribeKvStoreNotification008 begin.");
1035 std::vector<Entry> entries;
1036 Entry entry1, entry2, entry3;
1037
1038 entry1.key = "Id1";
1039 entry1.value = "subscribe";
1040 entry2.key = "Id2";
1041 entry2.value = "subscribe";
1042 entry3.key = "Id3";
1043 entry3.value = "subscribe";
1044 entries.push_back(entry1);
1045 entries.push_back(entry2);
1046 entries.push_back(entry3);
1047
1048 Status status = kvStore->PutBatch(entries);
1049 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1050
1051 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1052 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1053 status = kvStore->SubscribeKvStore(subscribeType, observer);
1054 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1055 entries.clear();
1056 entry1.key = "Id1";
1057 entry1.value = "subscribe_modify";
1058 entry2.key = "Id2";
1059 entry2.value = "subscribe_modify";
1060 entries.push_back(entry1);
1061 entries.push_back(entry2);
1062 status = kvStore->PutBatch(entries);
1063 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1064
1065 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1066 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 2);
1067 EXPECT_EQ("Id1", observer->updateEntries_[0].key.ToString());
1068 EXPECT_EQ("subscribe_modify", observer->updateEntries_[0].value.ToString());
1069 EXPECT_EQ("Id2", observer->updateEntries_[1].key.ToString());
1070 EXPECT_EQ("subscribe_modify", observer->updateEntries_[1].value.ToString());
1071
1072 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1073 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1074 }
1075
1076 /**
1077 * @tc.name: KvStoreDdmSubscribeKvStoreNotification009
1078 * @tc.desc: Subscribe to an observer, callback with notification one times after putbatch all different data
1079 * @tc.type: FUNC
1080 * @tc.require: AR000CIFGM
1081 * @tc.author: liuyuhui
1082 */
1083 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification009, TestSize.Level2)
1084 {
1085 ZLOGI("KvStoreDdmSubscribeKvStoreNotification009 begin.");
1086 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1087 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1088 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1089 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1090
1091 std::vector<Entry> entries;
1092 Entry entry1, entry2, entry3;
1093
1094 entry1.key = "Id1";
1095 entry1.value = "subscribe";
1096 entry2.key = "Id2";
1097 entry2.value = "subscribe";
1098 entry3.key = "Id3";
1099 entry3.value = "subscribe";
1100 entries.push_back(entry1);
1101 entries.push_back(entry2);
1102 entries.push_back(entry3);
1103
1104 status = kvStore->PutBatch(entries);
1105 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1106 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1107 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 3);
1108 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
1109 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
1110 EXPECT_EQ("Id2", observer->insertEntries_[1].key.ToString());
1111 EXPECT_EQ("subscribe", observer->insertEntries_[1].value.ToString());
1112 EXPECT_EQ("Id3", observer->insertEntries_[2].key.ToString());
1113 EXPECT_EQ("subscribe", observer->insertEntries_[2].value.ToString());
1114
1115 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1116 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1117 }
1118
1119 /**
1120 * @tc.name: KvStoreDdmSubscribeKvStoreNotification010
1121 * @tc.desc: Subscribe to an observer, callback with notification one times after putbatch both different and same data
1122 * @tc.type: FUNC
1123 * @tc.require: AR000CIFGM
1124 * @tc.author: liuyuhui
1125 */
1126 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification010, TestSize.Level2)
1127 {
1128 ZLOGI("KvStoreDdmSubscribeKvStoreNotification010 begin.");
1129 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1130 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1131 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1132 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1133
1134 std::vector<Entry> entries;
1135 Entry entry1, entry2, entry3;
1136
1137 entry1.key = "Id1";
1138 entry1.value = "subscribe";
1139 entry2.key = "Id1";
1140 entry2.value = "subscribe";
1141 entry3.key = "Id2";
1142 entry3.value = "subscribe";
1143 entries.push_back(entry1);
1144 entries.push_back(entry2);
1145 entries.push_back(entry3);
1146
1147 status = kvStore->PutBatch(entries);
1148 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1149 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1150 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 2);
1151 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
1152 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
1153 EXPECT_EQ("Id2", observer->insertEntries_[1].key.ToString());
1154 EXPECT_EQ("subscribe", observer->insertEntries_[1].value.ToString());
1155 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 0);
1156 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 0);
1157
1158 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1159 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1160 }
1161
1162 /**
1163 * @tc.name: KvStoreDdmSubscribeKvStoreNotification011
1164 * @tc.desc: Subscribe to an observer, callback with notification one times after putbatch all same data
1165 * @tc.type: FUNC
1166 * @tc.require: AR000CIFGM
1167 * @tc.author: liuyuhui
1168 */
1169 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification011, TestSize.Level2)
1170 {
1171 ZLOGI("KvStoreDdmSubscribeKvStoreNotification011 begin.");
1172 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1173 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1174 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1175 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1176
1177 std::vector<Entry> entries;
1178 Entry entry1, entry2, entry3;
1179
1180 entry1.key = "Id1";
1181 entry1.value = "subscribe";
1182 entry2.key = "Id1";
1183 entry2.value = "subscribe";
1184 entry3.key = "Id1";
1185 entry3.value = "subscribe";
1186 entries.push_back(entry1);
1187 entries.push_back(entry2);
1188 entries.push_back(entry3);
1189
1190 status = kvStore->PutBatch(entries);
1191 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1192 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1193 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
1194 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
1195 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
1196 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 0);
1197 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 0);
1198
1199 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1200 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1201 }
1202
1203 /**
1204 * @tc.name: KvStoreDdmSubscribeKvStoreNotification012
1205 * @tc.desc: Subscribe to an observer, callback with notification many times after putbatch all different data
1206 * @tc.type: FUNC
1207 * @tc.require: AR000CIFGM
1208 * @tc.author: liuyuhui
1209 */
1210 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification012, TestSize.Level2)
1211 {
1212 ZLOGI("KvStoreDdmSubscribeKvStoreNotification012 begin.");
1213 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1214 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1215 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1216 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1217
1218 std::vector<Entry> entries1;
1219 Entry entry1, entry2, entry3;
1220
1221 entry1.key = "Id1";
1222 entry1.value = "subscribe";
1223 entry2.key = "Id2";
1224 entry2.value = "subscribe";
1225 entry3.key = "Id3";
1226 entry3.value = "subscribe";
1227 entries1.push_back(entry1);
1228 entries1.push_back(entry2);
1229 entries1.push_back(entry3);
1230
1231 std::vector<Entry> entries2;
1232 Entry entry4, entry5;
1233 entry4.key = "Id4";
1234 entry4.value = "subscribe";
1235 entry5.key = "Id5";
1236 entry5.value = "subscribe";
1237 entries2.push_back(entry4);
1238 entries2.push_back(entry5);
1239
1240 status = kvStore->PutBatch(entries1);
1241 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1242 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1243 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 3);
1244 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
1245 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
1246 EXPECT_EQ("Id2", observer->insertEntries_[1].key.ToString());
1247 EXPECT_EQ("subscribe", observer->insertEntries_[1].value.ToString());
1248 EXPECT_EQ("Id3", observer->insertEntries_[2].key.ToString());
1249 EXPECT_EQ("subscribe", observer->insertEntries_[2].value.ToString());
1250
1251 status = kvStore->PutBatch(entries2);
1252 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1253 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
1254 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 2);
1255 EXPECT_EQ("Id4", observer->insertEntries_[0].key.ToString());
1256 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
1257 EXPECT_EQ("Id5", observer->insertEntries_[1].key.ToString());
1258 EXPECT_EQ("subscribe", observer->insertEntries_[1].value.ToString());
1259
1260 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1261 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1262 }
1263
1264 /**
1265 * @tc.name: KvStoreDdmSubscribeKvStoreNotification013
1266 * @tc.desc: Subscribe to an observer, callback with notification many times after putbatch both different and same data
1267 * @tc.type: FUNC
1268 * @tc.require: AR000CIFGM
1269 * @tc.author: liuyuhui
1270 */
1271 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification013, TestSize.Level2)
1272 {
1273 ZLOGI("KvStoreDdmSubscribeKvStoreNotification013 begin.");
1274 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1275 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1276 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1277 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1278
1279 std::vector<Entry> entries1;
1280 Entry entry1, entry2, entry3;
1281
1282 entry1.key = "Id1";
1283 entry1.value = "subscribe";
1284 entry2.key = "Id2";
1285 entry2.value = "subscribe";
1286 entry3.key = "Id3";
1287 entry3.value = "subscribe";
1288 entries1.push_back(entry1);
1289 entries1.push_back(entry2);
1290 entries1.push_back(entry3);
1291
1292 std::vector<Entry> entries2;
1293 Entry entry4, entry5;
1294 entry4.key = "Id1";
1295 entry4.value = "subscribe";
1296 entry5.key = "Id4";
1297 entry5.value = "subscribe";
1298 entries2.push_back(entry4);
1299 entries2.push_back(entry5);
1300
1301 status = kvStore->PutBatch(entries1);
1302 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1303 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1304 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 3);
1305 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
1306 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
1307 EXPECT_EQ("Id2", observer->insertEntries_[1].key.ToString());
1308 EXPECT_EQ("subscribe", observer->insertEntries_[1].value.ToString());
1309 EXPECT_EQ("Id3", observer->insertEntries_[2].key.ToString());
1310 EXPECT_EQ("subscribe", observer->insertEntries_[2].value.ToString());
1311
1312 status = kvStore->PutBatch(entries2);
1313 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1314 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
1315 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 1);
1316 EXPECT_EQ("Id1", observer->updateEntries_[0].key.ToString());
1317 EXPECT_EQ("subscribe", observer->updateEntries_[0].value.ToString());
1318 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
1319 EXPECT_EQ("Id4", observer->insertEntries_[0].key.ToString());
1320 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
1321
1322 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1323 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1324 }
1325
1326 /**
1327 * @tc.name: KvStoreDdmSubscribeKvStoreNotification014
1328 * @tc.desc: Subscribe to an observer, callback with notification many times after putbatch all same data
1329 * @tc.type: FUNC
1330 * @tc.require: AR000CIFGM
1331 * @tc.author: liuyuhui
1332 */
1333 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification014, TestSize.Level2)
1334 {
1335 ZLOGI("KvStoreDdmSubscribeKvStoreNotification014 begin.");
1336 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1337 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1338 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1339 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1340
1341 std::vector<Entry> entries1;
1342 Entry entry1, entry2, entry3;
1343
1344 entry1.key = "Id1";
1345 entry1.value = "subscribe";
1346 entry2.key = "Id2";
1347 entry2.value = "subscribe";
1348 entry3.key = "Id3";
1349 entry3.value = "subscribe";
1350 entries1.push_back(entry1);
1351 entries1.push_back(entry2);
1352 entries1.push_back(entry3);
1353
1354 std::vector<Entry> entries2;
1355 Entry entry4, entry5;
1356 entry4.key = "Id1";
1357 entry4.value = "subscribe";
1358 entry5.key = "Id2";
1359 entry5.value = "subscribe";
1360 entries2.push_back(entry4);
1361 entries2.push_back(entry5);
1362
1363 status = kvStore->PutBatch(entries1);
1364 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1365 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1366 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 3);
1367 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
1368 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
1369 EXPECT_EQ("Id2", observer->insertEntries_[1].key.ToString());
1370 EXPECT_EQ("subscribe", observer->insertEntries_[1].value.ToString());
1371 EXPECT_EQ("Id3", observer->insertEntries_[2].key.ToString());
1372 EXPECT_EQ("subscribe", observer->insertEntries_[2].value.ToString());
1373
1374 status = kvStore->PutBatch(entries2);
1375 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1376 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
1377 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 2);
1378 EXPECT_EQ("Id1", observer->updateEntries_[0].key.ToString());
1379 EXPECT_EQ("subscribe", observer->updateEntries_[0].value.ToString());
1380 EXPECT_EQ("Id2", observer->updateEntries_[1].key.ToString());
1381 EXPECT_EQ("subscribe", observer->updateEntries_[1].value.ToString());
1382
1383 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1384 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1385 }
1386
1387 /**
1388 * @tc.name: KvStoreDdmSubscribeKvStoreNotification015
1389 * @tc.desc: Subscribe to an observer, callback with notification many times after putbatch complex data
1390 * @tc.type: FUNC
1391 * @tc.require: AR000CIFGM
1392 * @tc.author: liuyuhui
1393 */
1394 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification015, TestSize.Level2)
1395 {
1396 ZLOGI("KvStoreDdmSubscribeKvStoreNotification015 begin.");
1397 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1398 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1399 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1400 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1401
1402 std::vector<Entry> entries1;
1403 Entry entry1, entry2, entry3;
1404
1405 entry1.key = "Id1";
1406 entry1.value = "subscribe";
1407 entry2.key = "Id1";
1408 entry2.value = "subscribe";
1409 entry3.key = "Id3";
1410 entry3.value = "subscribe";
1411 entries1.push_back(entry1);
1412 entries1.push_back(entry2);
1413 entries1.push_back(entry3);
1414
1415 std::vector<Entry> entries2;
1416 Entry entry4, entry5;
1417 entry4.key = "Id1";
1418 entry4.value = "subscribe";
1419 entry5.key = "Id2";
1420 entry5.value = "subscribe";
1421 entries2.push_back(entry4);
1422 entries2.push_back(entry5);
1423
1424 status = kvStore->PutBatch(entries1);
1425 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1426 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1427 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 0);
1428 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 0);
1429 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 2);
1430 EXPECT_EQ("Id1", observer->insertEntries_[0].key.ToString());
1431 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
1432 EXPECT_EQ("Id3", observer->insertEntries_[1].key.ToString());
1433 EXPECT_EQ("subscribe", observer->insertEntries_[1].value.ToString());
1434
1435 status = kvStore->PutBatch(entries2);
1436 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1437 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
1438 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 1);
1439 EXPECT_EQ("Id1", observer->updateEntries_[0].key.ToString());
1440 EXPECT_EQ("subscribe", observer->updateEntries_[0].value.ToString());
1441 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 1);
1442 EXPECT_EQ("Id2", observer->insertEntries_[0].key.ToString());
1443 EXPECT_EQ("subscribe", observer->insertEntries_[0].value.ToString());
1444
1445 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1446 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1447 }
1448
1449 /**
1450 * @tc.name: KvStoreDdmSubscribeKvStoreNotification016
1451 * @tc.desc: Pressure test subscribe, callback with notification many times after putbatch
1452 * @tc.type: FUNC
1453 * @tc.require: AR000CIFGM
1454 * @tc.author: liuyuhui
1455 */
1456 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification016, TestSize.Level2)
1457 {
1458 ZLOGI("KvStoreDdmSubscribeKvStoreNotification016 begin.");
1459 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1460 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1461 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1462 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1463
1464 const int ENTRIES_MAX_LEN = 100;
1465 std::vector<Entry> entries;
1466 for (int i = 0; i < ENTRIES_MAX_LEN; i++) {
1467 Entry entry;
1468 entry.key = std::to_string(i);
1469 entry.value = "subscribe";
1470 entries.push_back(entry);
1471 }
1472
1473 status = kvStore->PutBatch(entries);
1474 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1475 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1476 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 100);
1477
1478 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1479 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1480 }
1481
1482 /**
1483 * @tc.name: KvStoreDdmSubscribeKvStoreNotification017
1484 * @tc.desc: Subscribe to an observer, callback with notification after delete success
1485 * @tc.type: FUNC
1486 * @tc.require: AR000CIFGM
1487 * @tc.author: liuyuhui
1488 */
1489 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification017, TestSize.Level2)
1490 {
1491 ZLOGI("KvStoreDdmSubscribeKvStoreNotification017 begin.");
1492 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1493 std::vector<Entry> entries;
1494 Entry entry1, entry2, entry3;
1495 entry1.key = "Id1";
1496 entry1.value = "subscribe";
1497 entry2.key = "Id2";
1498 entry2.value = "subscribe";
1499 entry3.key = "Id3";
1500 entry3.value = "subscribe";
1501 entries.push_back(entry1);
1502 entries.push_back(entry2);
1503 entries.push_back(entry3);
1504
1505 Status status = kvStore->PutBatch(entries);
1506 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1507
1508 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1509 status = kvStore->SubscribeKvStore(subscribeType, observer);
1510 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1511 status = kvStore->Delete("Id1");
1512 EXPECT_EQ(Status::SUCCESS, status) << "KvStore Delete data return wrong status";
1513 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1514 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 1);
1515 EXPECT_EQ("Id1", observer->deleteEntries_[0].key.ToString());
1516 EXPECT_EQ("subscribe", observer->deleteEntries_[0].value.ToString());
1517
1518 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1519 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1520 }
1521
1522 /**
1523 * @tc.name: KvStoreDdmSubscribeKvStoreNotification018
1524 * @tc.desc: Subscribe to an observer, not callback after delete which key not exist
1525 * @tc.type: FUNC
1526 * @tc.require: AR000CIFGM
1527 * @tc.author: liuyuhui
1528 */
1529 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification018, TestSize.Level2)
1530 {
1531 ZLOGI("KvStoreDdmSubscribeKvStoreNotification018 begin.");
1532 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1533 std::vector<Entry> entries;
1534 Entry entry1, entry2, entry3;
1535 entry1.key = "Id1";
1536 entry1.value = "subscribe";
1537 entry2.key = "Id2";
1538 entry2.value = "subscribe";
1539 entry3.key = "Id3";
1540 entry3.value = "subscribe";
1541 entries.push_back(entry1);
1542 entries.push_back(entry2);
1543 entries.push_back(entry3);
1544
1545 Status status = kvStore->PutBatch(entries);
1546 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1547
1548 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1549 status = kvStore->SubscribeKvStore(subscribeType, observer);
1550 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1551 status = kvStore->Delete("Id4");
1552 EXPECT_EQ(Status::SUCCESS, status) << "KvStore Delete data return wrong status";
1553 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 0);
1554 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 0);
1555
1556 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1557 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1558 }
1559
1560 /**
1561 * @tc.name: KvStoreDdmSubscribeKvStoreNotification019
1562 * @tc.desc: Subscribe to an observer, delete the same data many times and only first delete callback with notification
1563 * @tc.type: FUNC
1564 * @tc.require: AR000CIFGM
1565 * @tc.author: liuyuhui
1566 */
1567 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification019, TestSize.Level2)
1568 {
1569 ZLOGI("KvStoreDdmSubscribeKvStoreNotification019 begin.");
1570 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1571 std::vector<Entry> entries;
1572 Entry entry1, entry2, entry3;
1573 entry1.key = "Id1";
1574 entry1.value = "subscribe";
1575 entry2.key = "Id2";
1576 entry2.value = "subscribe";
1577 entry3.key = "Id3";
1578 entry3.value = "subscribe";
1579 entries.push_back(entry1);
1580 entries.push_back(entry2);
1581 entries.push_back(entry3);
1582
1583 Status status = kvStore->PutBatch(entries);
1584 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1585
1586 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1587 status = kvStore->SubscribeKvStore(subscribeType, observer);
1588 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1589 status = kvStore->Delete("Id1");
1590 EXPECT_EQ(Status::SUCCESS, status) << "KvStore Delete data return wrong status";
1591 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1592 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 1);
1593 EXPECT_EQ("Id1", observer->deleteEntries_[0].key.ToString());
1594 EXPECT_EQ("subscribe", observer->deleteEntries_[0].value.ToString());
1595
1596 status = kvStore->Delete("Id1");
1597 EXPECT_EQ(Status::SUCCESS, status) << "KvStore Delete data return wrong status";
1598 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 1);
1599 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 1); // not callback so not clear
1600
1601 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1602 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1603 }
1604
1605 /**
1606 * @tc.name: KvStoreDdmSubscribeKvStoreNotification020
1607 * @tc.desc: Subscribe to an observer, callback with notification after deleteBatch
1608 * @tc.type: FUNC
1609 * @tc.require: AR000CIFGM
1610 * @tc.author: liuyuhui
1611 */
1612 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification020, TestSize.Level2)
1613 {
1614 ZLOGI("KvStoreDdmSubscribeKvStoreNotification020 begin.");
1615 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1616 std::vector<Entry> entries;
1617 Entry entry1, entry2, entry3;
1618 entry1.key = "Id1";
1619 entry1.value = "subscribe";
1620 entry2.key = "Id2";
1621 entry2.value = "subscribe";
1622 entry3.key = "Id3";
1623 entry3.value = "subscribe";
1624 entries.push_back(entry1);
1625 entries.push_back(entry2);
1626 entries.push_back(entry3);
1627
1628 std::vector<Key> keys;
1629 keys.push_back("Id1");
1630 keys.push_back("Id2");
1631
1632 Status status = kvStore->PutBatch(entries);
1633 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1634
1635 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1636 status = kvStore->SubscribeKvStore(subscribeType, observer);
1637 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1638
1639 status = kvStore->DeleteBatch(keys);
1640 EXPECT_EQ(Status::SUCCESS, status) << "KvStore DeleteBatch data return wrong status";
1641 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1642 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 2);
1643 EXPECT_EQ("Id1", observer->deleteEntries_[0].key.ToString());
1644 EXPECT_EQ("subscribe", observer->deleteEntries_[0].value.ToString());
1645 EXPECT_EQ("Id2", observer->deleteEntries_[1].key.ToString());
1646 EXPECT_EQ("subscribe", observer->deleteEntries_[1].value.ToString());
1647
1648 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1649 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1650 }
1651
1652 /**
1653 * @tc.name: KvStoreDdmSubscribeKvStoreNotification021
1654 * @tc.desc: Subscribe to an observer, not callback after deleteBatch which all keys not exist
1655 * @tc.type: FUNC
1656 * @tc.require: AR000CIFGM
1657 * @tc.author: liuyuhui
1658 */
1659 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification021, TestSize.Level2)
1660 {
1661 ZLOGI("KvStoreDdmSubscribeKvStoreNotification021 begin.");
1662 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1663 std::vector<Entry> entries;
1664 Entry entry1, entry2, entry3;
1665 entry1.key = "Id1";
1666 entry1.value = "subscribe";
1667 entry2.key = "Id2";
1668 entry2.value = "subscribe";
1669 entry3.key = "Id3";
1670 entry3.value = "subscribe";
1671 entries.push_back(entry1);
1672 entries.push_back(entry2);
1673 entries.push_back(entry3);
1674
1675 std::vector<Key> keys;
1676 keys.push_back("Id4");
1677 keys.push_back("Id5");
1678
1679 Status status = kvStore->PutBatch(entries);
1680 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1681
1682 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1683 status = kvStore->SubscribeKvStore(subscribeType, observer);
1684 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1685
1686 status = kvStore->DeleteBatch(keys);
1687 EXPECT_EQ(Status::SUCCESS, status) << "KvStore DeleteBatch data return wrong status";
1688 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 0);
1689 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 0);
1690
1691 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1692 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1693 }
1694
1695 /**
1696 * @tc.name: KvStoreDdmSubscribeKvStoreNotification022
1697 * @tc.desc: Subscribe to an observer, deletebatch the same data many times and only first deletebatch callback with
1698 * notification
1699 * @tc.type: FUNC
1700 * @tc.require: AR000CIFGM
1701 * @tc.author: liuyuhui
1702 */
1703 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification022, TestSize.Level2)
1704 {
1705 ZLOGI("KvStoreDdmSubscribeKvStoreNotification022 begin.");
1706 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1707 std::vector<Entry> entries;
1708 Entry entry1, entry2, entry3;
1709 entry1.key = "Id1";
1710 entry1.value = "subscribe";
1711 entry2.key = "Id2";
1712 entry2.value = "subscribe";
1713 entry3.key = "Id3";
1714 entry3.value = "subscribe";
1715 entries.push_back(entry1);
1716 entries.push_back(entry2);
1717 entries.push_back(entry3);
1718
1719 std::vector<Key> keys;
1720 keys.push_back("Id1");
1721 keys.push_back("Id2");
1722
1723 Status status = kvStore->PutBatch(entries);
1724 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1725
1726 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1727 status = kvStore->SubscribeKvStore(subscribeType, observer);
1728 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1729
1730 status = kvStore->DeleteBatch(keys);
1731 EXPECT_EQ(Status::SUCCESS, status) << "KvStore DeleteBatch data return wrong status";
1732 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1733 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 2);
1734 EXPECT_EQ("Id1", observer->deleteEntries_[0].key.ToString());
1735 EXPECT_EQ("subscribe", observer->deleteEntries_[0].value.ToString());
1736 EXPECT_EQ("Id2", observer->deleteEntries_[1].key.ToString());
1737 EXPECT_EQ("subscribe", observer->deleteEntries_[1].value.ToString());
1738
1739 status = kvStore->DeleteBatch(keys);
1740 EXPECT_EQ(Status::SUCCESS, status) << "KvStore DeleteBatch data return wrong status";
1741 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 1);
1742 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 2); // not callback so not clear
1743
1744 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1745 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1746 }
1747
1748 /**
1749 * @tc.name: KvStoreDdmSubscribeKvStoreNotification023
1750 * @tc.desc: Subscribe to an observer, include Clear Put PutBatch Delete DeleteBatch
1751 * @tc.type: FUNC
1752 * @tc.require: AR000CIFGM
1753 * @tc.author: liuyuhui
1754 */
1755 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification023, TestSize.Level2)
1756 {
1757 ZLOGI("KvStoreDdmSubscribeKvStoreNotification023 begin.");
1758 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1759 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1760 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1761 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1762
1763 Key key1 = "Id1";
1764 Value value1 = "subscribe";
1765
1766 std::vector<Entry> entries;
1767 Entry entry1, entry2, entry3;
1768 entry1.key = "Id2";
1769 entry1.value = "subscribe";
1770 entry2.key = "Id3";
1771 entry2.value = "subscribe";
1772 entry3.key = "Id4";
1773 entry3.value = "subscribe";
1774 entries.push_back(entry1);
1775 entries.push_back(entry2);
1776 entries.push_back(entry3);
1777
1778 std::vector<Key> keys;
1779 keys.push_back("Id2");
1780 keys.push_back("Id3");
1781
1782 status = kvStore->Put(key1, value1); // insert or update key-value
1783 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
1784 status = kvStore->PutBatch(entries);
1785 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1786 status = kvStore->Delete(key1);
1787 EXPECT_EQ(Status::SUCCESS, status) << "KvStore delete data return wrong status";
1788 status = kvStore->DeleteBatch(keys);
1789 EXPECT_EQ(Status::SUCCESS, status) << "KvStore DeleteBatch data return wrong status";
1790 EXPECT_EQ(static_cast<int>(observer->GetCallCount(4)), 4);
1791 // every callback will clear vector
1792 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 2);
1793 EXPECT_EQ("Id2", observer->deleteEntries_[0].key.ToString());
1794 EXPECT_EQ("subscribe", observer->deleteEntries_[0].value.ToString());
1795 EXPECT_EQ("Id3", observer->deleteEntries_[1].key.ToString());
1796 EXPECT_EQ("subscribe", observer->deleteEntries_[1].value.ToString());
1797 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 0);
1798 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 0);
1799
1800 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1801 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1802 }
1803
1804 /**
1805 * @tc.name: KvStoreDdmSubscribeKvStoreNotification024
1806 * @tc.desc: Subscribe to an observer[use transaction], include Clear Put PutBatch Delete DeleteBatch
1807 * @tc.type: FUNC
1808 * @tc.require: AR000CIFGM
1809 * @tc.author: liuyuhui
1810 */
1811 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification024, TestSize.Level2)
1812 {
1813 ZLOGI("KvStoreDdmSubscribeKvStoreNotification024 begin.");
1814 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1815 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1816 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1817 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1818
1819 Key key1 = "Id1";
1820 Value value1 = "subscribe";
1821
1822 std::vector<Entry> entries;
1823 Entry entry1, entry2, entry3;
1824 entry1.key = "Id2";
1825 entry1.value = "subscribe";
1826 entry2.key = "Id3";
1827 entry2.value = "subscribe";
1828 entry3.key = "Id4";
1829 entry3.value = "subscribe";
1830 entries.push_back(entry1);
1831 entries.push_back(entry2);
1832 entries.push_back(entry3);
1833
1834 std::vector<Key> keys;
1835 keys.push_back("Id2");
1836 keys.push_back("Id3");
1837
1838 status = kvStore->StartTransaction();
1839 EXPECT_EQ(Status::SUCCESS, status) << "KvStore startTransaction return wrong status";
1840 status = kvStore->Put(key1, value1); // insert or update key-value
1841 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
1842 status = kvStore->PutBatch(entries);
1843 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1844 status = kvStore->Delete(key1);
1845 EXPECT_EQ(Status::SUCCESS, status) << "KvStore delete data return wrong status";
1846 status = kvStore->DeleteBatch(keys);
1847 EXPECT_EQ(Status::SUCCESS, status) << "KvStore DeleteBatch data return wrong status";
1848 status = kvStore->Commit();
1849 EXPECT_EQ(Status::SUCCESS, status) << "KvStore Commit return wrong status";
1850 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1851
1852 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1853 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1854 }
1855
1856 /**
1857 * @tc.name: KvStoreDdmSubscribeKvStoreNotification025
1858 * @tc.desc: Subscribe to an observer[use transaction], include Clear Put PutBatch Delete DeleteBatch
1859 * @tc.type: FUNC
1860 * @tc.require: AR000CIFGM
1861 * @tc.author: liuyuhui
1862 */
1863 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification025, TestSize.Level2)
1864 {
1865 ZLOGI("KvStoreDdmSubscribeKvStoreNotification025 begin.");
1866 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1867 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1868 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1869 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1870
1871 Key key1 = "Id1";
1872 Value value1 = "subscribe";
1873
1874 std::vector<Entry> entries;
1875 Entry entry1, entry2, entry3;
1876 entry1.key = "Id2";
1877 entry1.value = "subscribe";
1878 entry2.key = "Id3";
1879 entry2.value = "subscribe";
1880 entry3.key = "Id4";
1881 entry3.value = "subscribe";
1882 entries.push_back(entry1);
1883 entries.push_back(entry2);
1884 entries.push_back(entry3);
1885
1886 std::vector<Key> keys;
1887 keys.push_back("Id2");
1888 keys.push_back("Id3");
1889
1890 status = kvStore->StartTransaction();
1891 EXPECT_EQ(Status::SUCCESS, status) << "KvStore startTransaction return wrong status";
1892 status = kvStore->Put(key1, value1); // insert or update key-value
1893 EXPECT_EQ(Status::SUCCESS, status) << "KvStore put data return wrong status";
1894 status = kvStore->PutBatch(entries);
1895 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1896 status = kvStore->Delete(key1);
1897 EXPECT_EQ(Status::SUCCESS, status) << "KvStore delete data return wrong status";
1898 status = kvStore->DeleteBatch(keys);
1899 EXPECT_EQ(Status::SUCCESS, status) << "KvStore DeleteBatch data return wrong status";
1900 status = kvStore->Rollback();
1901 EXPECT_EQ(Status::SUCCESS, status) << "KvStore Commit return wrong status";
1902 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 0);
1903 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 0);
1904 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 0);
1905 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 0);
1906
1907 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
1908 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
1909 observer = nullptr;
1910 }
1911
1912 /**
1913 * @tc.name: KvStoreDdmSubscribeKvStoreNotification026
1914 * @tc.desc: Subscribe to an observer[use transaction], include bigData PutBatch update insert delete
1915 * @tc.type: FUNC
1916 * @tc.require: AR000CIFGM
1917 * @tc.author: dukaizhan
1918 */
1919 HWTEST_F(LocalSubscribeStoreTest, KvStoreDdmSubscribeKvStoreNotification026, TestSize.Level2)
1920 {
1921 ZLOGI("KvStoreDdmSubscribeKvStoreNotification026 begin.");
1922 auto observer = std::make_shared<KvStoreObserverUnitTest>();
1923 SubscribeType subscribeType = SubscribeType::SUBSCRIBE_TYPE_ALL;
1924 Status status = kvStore->SubscribeKvStore(subscribeType, observer);
1925 EXPECT_EQ(Status::SUCCESS, status) << "SubscribeKvStore return wrong status";
1926
1927 std::vector<Entry> entries;
1928 Entry entry0, entry1, entry2, entry3, entry4, entry5, entry6, entry7;
1929
1930 int maxValueSize = 2 * 1024 * 1024; // max value size is 2M.
1931 std::vector<uint8_t> val(maxValueSize);
1932 for (int i = 0; i < maxValueSize; i++) {
1933 val[i] = static_cast<uint8_t>(i);
1934 }
1935 Value value = val;
1936
1937 int maxValueSize2 = 1000 * 1024; // max value size is 1000k.
1938 std::vector<uint8_t> val2(maxValueSize2);
1939 for (int i = 0; i < maxValueSize2; i++) {
1940 val2[i] = static_cast<uint8_t>(i);
1941 }
1942 Value value2 = val2;
1943
1944 entry0.key = "SingleKvStoreDdmPutBatch006_0";
1945 entry0.value = "beijing";
1946 entry1.key = "SingleKvStoreDdmPutBatch006_1";
1947 entry1.value = value;
1948 entry2.key = "SingleKvStoreDdmPutBatch006_2";
1949 entry2.value = value;
1950 entry3.key = "SingleKvStoreDdmPutBatch006_3";
1951 entry3.value = "ZuiHouBuZhiTianZaiShui";
1952 entry4.key = "SingleKvStoreDdmPutBatch006_4";
1953 entry4.value = value;
1954
1955 entries.push_back(entry0);
1956 entries.push_back(entry1);
1957 entries.push_back(entry2);
1958 entries.push_back(entry3);
1959 entries.push_back(entry4);
1960
1961 status = kvStore->PutBatch(entries);
1962 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putbatch data return wrong status";
1963
1964 EXPECT_EQ(static_cast<int>(observer->GetCallCount()), 1);
1965 EXPECT_EQ(static_cast<int>(observer->insertEntries_.size()), 5);
1966 EXPECT_EQ("SingleKvStoreDdmPutBatch006_0", observer->insertEntries_[0].key.ToString());
1967 EXPECT_EQ("beijing", observer->insertEntries_[0].value.ToString());
1968 EXPECT_EQ("SingleKvStoreDdmPutBatch006_1", observer->insertEntries_[1].key.ToString());
1969 EXPECT_EQ("SingleKvStoreDdmPutBatch006_2", observer->insertEntries_[2].key.ToString());
1970 EXPECT_EQ("SingleKvStoreDdmPutBatch006_3", observer->insertEntries_[3].key.ToString());
1971 EXPECT_EQ("ZuiHouBuZhiTianZaiShui", observer->insertEntries_[3].value.ToString());
1972
1973 entry5.key = "SingleKvStoreDdmPutBatch006_2";
1974 entry5.value = val2;
1975 entry6.key = "SingleKvStoreDdmPutBatch006_3";
1976 entry6.value = "ManChuanXingMengYaXingHe";
1977 entry7.key = "SingleKvStoreDdmPutBatch006_4";
1978 entry7.value = val2;
1979 std::vector<Entry> updateEntries;
1980 updateEntries.push_back(entry5);
1981 updateEntries.push_back(entry6);
1982 updateEntries.push_back(entry7);
1983 status = kvStore->PutBatch(updateEntries);
1984 EXPECT_EQ(Status::SUCCESS, status) << "KvStore putBatch update data return wrong status";
1985
1986 EXPECT_EQ(static_cast<int>(observer->GetCallCount(2)), 2);
1987 EXPECT_EQ(static_cast<int>(observer->updateEntries_.size()), 3);
1988 EXPECT_EQ("SingleKvStoreDdmPutBatch006_2", observer->updateEntries_[0].key.ToString());
1989 EXPECT_EQ("SingleKvStoreDdmPutBatch006_3", observer->updateEntries_[1].key.ToString());
1990 EXPECT_EQ("ManChuanXingMengYaXingHe", observer->updateEntries_[1].value.ToString());
1991 EXPECT_EQ("SingleKvStoreDdmPutBatch006_4", observer->updateEntries_[2].key.ToString());
1992 EXPECT_EQ(false, observer->isClear_);
1993
1994 status = kvStore->Delete("SingleKvStoreDdmPutBatch006_3");
1995 EXPECT_EQ(Status::SUCCESS, status) << "KvStore delete data return wrong status";
1996 EXPECT_EQ(static_cast<int>(observer->GetCallCount(3)), 3);
1997 EXPECT_EQ(static_cast<int>(observer->deleteEntries_.size()), 1);
1998 EXPECT_EQ("SingleKvStoreDdmPutBatch006_3", observer->deleteEntries_[0].key.ToString());
1999
2000 status = kvStore->UnSubscribeKvStore(subscribeType, observer);
2001 EXPECT_EQ(Status::SUCCESS, status) << "UnSubscribeKvStore return wrong status";
2002 }
2003