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