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