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