1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <gtest/gtest.h>
16 #include <ctime>
17 #include <cmath>
18 #include <chrono>
19 #include <thread>
20 #include <cstdio>
21 #include <random>
22 #include <string>
23 
24 #include "kv_store_delegate.h"
25 #include "kv_store_nb_delegate.h"
26 #include "distributeddb_nb_test_tools.h"
27 #include "kv_store_delegate_manager.h"
28 #include "distributeddb_data_generator.h"
29 #include "distributed_test_tools.h"
30 
31 using namespace std;
32 using namespace chrono;
33 using namespace testing;
34 #if defined TESTCASES_USING_GTEST_EXT
35 using namespace testing::ext;
36 #endif
37 using namespace DistributedDB;
38 using namespace DistributedDBDataGenerator;
39 
40 namespace DistributeddbNbObserver {
41 const int CHANGED_ZERO_TIME = 0;
42 const int CHANGED_ONE_TIME = 1;
43 const int STORE_NUM = 2;
44 
45 const unsigned int ANY_RECORDS_NUM_START = 1;
46 const unsigned int ANY_RECORDS_NUM_END = 1000;
47 
48 const unsigned int LONG_TIME_TEST_SECONDS = 10;
49 const unsigned int LONG_TIME_INTERVAL_MILLSECONDS = 5;
50 
51 KvStoreNbDelegate *g_nbObserverDelegate = nullptr;
52 KvStoreDelegateManager *g_nbObserverManager = nullptr;
53 
54 struct ConcurParam {
55     unsigned int threadId_;
56     ReadOrWriteTag tag_;
57     Entry* entryPtr_;
58 };
59 
60 DistributedDB::CipherPassword g_passwd1;
61 DistributedDB::CipherPassword g_passwd2;
62 
63 class DistributeddbNbObserverTest : public testing::Test {
64 public:
65     static void SetUpTestCase(void);
66     static void TearDownTestCase(void);
67     void SetUp();
68     void TearDown();
69 private:
70 };
71 
SetUpTestCase(void)72 void DistributeddbNbObserverTest::SetUpTestCase(void)
73 {
74     (void)g_passwd1.SetValue(PASSWD_VECTOR_1.data(), PASSWD_VECTOR_1.size());
75     (void)g_passwd2.SetValue(PASSWD_VECTOR_2.data(), PASSWD_VECTOR_2.size());
76 }
77 
TearDownTestCase(void)78 void DistributeddbNbObserverTest::TearDownTestCase(void)
79 {
80 }
81 
SetUp(void)82 void DistributeddbNbObserverTest::SetUp(void)
83 {
84     MST_LOG("SetUpTest before case local.");
85     RemoveDir(DistributedDBConstant::NB_DIRECTOR);
86 
87     UnitTest *test = UnitTest::GetInstance();
88     ASSERT_NE(test, nullptr);
89     const TestInfo *testinfo = test->current_test_info();
90     ASSERT_NE(testinfo, nullptr);
91     string testCaseName = string(testinfo->name());
92     MST_LOG("[SetUp] test case %s is start to run", testCaseName.c_str());
93 
94     g_nbObserverDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_nbObserverManager,
95         g_dbParameter1, g_option);
96     EXPECT_TRUE(g_nbObserverManager != nullptr && g_nbObserverDelegate != nullptr);
97 }
98 
TearDown(void)99 void DistributeddbNbObserverTest::TearDown(void)
100 {
101     EXPECT_TRUE(EndCaseDeleteDB(g_nbObserverManager, g_nbObserverDelegate, STORE_ID_1, g_option.isMemoryDb));
102     RemoveDir(DistributedDBConstant::NB_DIRECTOR);
103 }
104 
RegisterAndUnRegisterObserver(ConcurParam * paramsPtr)105 void RegisterAndUnRegisterObserver(ConcurParam* paramsPtr)
106 {
107     KvStoreObserverImpl observerLocal;
108     KvStoreObserverImpl observerSync;
109     DBStatus status = g_nbObserverDelegate->RegisterObserver(
110         paramsPtr->entryPtr_->key, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
111     EXPECT_EQ(status, OK);
112     status = g_nbObserverDelegate->RegisterObserver(
113         paramsPtr->entryPtr_->key, OBSERVER_CHANGES_NATIVE, &observerSync);
114     EXPECT_EQ(status, OK);
115     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
116     EXPECT_EQ(status, OK);
117     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
118     EXPECT_EQ(status, OK);
119 }
120 
ConcurOperThread(ConcurParam * args)121 void ConcurOperThread(ConcurParam* args)
122 {
123     auto paramsPtr = static_cast<ConcurParam *>(args);
124     DBStatus status;
125     Value valueResult;
126 
127     if (paramsPtr->tag_ == ReadOrWriteTag::READ) {
128         status = DistributedDBNbTestTools::Get(*g_nbObserverDelegate, paramsPtr->entryPtr_->key, valueResult);
129         if (valueResult.size() != 0) {
130             EXPECT_EQ(status, OK);
131             EXPECT_TRUE(DistributedDBNbTestTools::isValueEquals(valueResult, paramsPtr->entryPtr_->value));
132         }
133     } else if (paramsPtr->tag_ == ReadOrWriteTag::WRITE) {
134         status = DistributedDBNbTestTools::Put(*g_nbObserverDelegate,
135             paramsPtr->entryPtr_->key, paramsPtr->entryPtr_->value);
136         ASSERT_EQ(status, DBStatus::OK);
137 
138         status = DistributedDBNbTestTools::Get(*g_nbObserverDelegate, paramsPtr->entryPtr_->key, valueResult);
139         EXPECT_EQ(status, OK);
140         EXPECT_TRUE(DistributedDBNbTestTools::isValueEquals(valueResult, paramsPtr->entryPtr_->value));
141     } else if (paramsPtr->tag_ == ReadOrWriteTag::DELETE) {
142         status = DistributedDBNbTestTools::Get(*g_nbObserverDelegate, paramsPtr->entryPtr_->key, valueResult);
143         if (valueResult.size() != 0) {
144             status = DistributedDBNbTestTools::Delete(*g_nbObserverDelegate, paramsPtr->entryPtr_->key);
145             ASSERT_EQ(status, DBStatus::OK);
146 
147             valueResult.clear();
148             status = DistributedDBNbTestTools::Get(*g_nbObserverDelegate, paramsPtr->entryPtr_->key, valueResult);
149             EXPECT_EQ(status, NOT_FOUND);
150             EXPECT_EQ(valueResult.size(), (size_t)0);
151         } else {
152             status = DistributedDBNbTestTools::Delete(*g_nbObserverDelegate, paramsPtr->entryPtr_->key);
153             ASSERT_EQ(status, DBStatus::OK);
154         }
155     } else {
156         RegisterAndUnRegisterObserver(paramsPtr);
157     }
158 }
159 
160 /*
161  * @tc.name: RegisterData 001
162  * @tc.desc: Verify that observer of local db and sync db can't effect each other.
163  * @tc.type: FUNC
164  * @tc.require: SR000CQDVH
165  * @tc.author: luqianfu
166  */
167 HWTEST_F(DistributeddbNbObserverTest, RegisterData001, TestSize.Level1)
168 {
169     KvStoreObserverImpl observerLocal;
170     KvStoreObserverImpl observerSync;
171     /**
172      * @tc.steps: step1. register local observer1 use OBSERVER_CHANGES_LOCAL_ONLY mode.
173      * @tc.expected: step1. register success.
174      */
175     DBStatus status = g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
176     EXPECT_EQ(status, OK);
177     /**
178      * @tc.steps: step2. register sync observer2 use OBSERVER_CHANGES_NATIVE.
179      * @tc.expected: step2. register success.
180      */
181     status = g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_NATIVE, &observerSync);
182     EXPECT_EQ(status, OK);
183     /**
184      * @tc.steps: step3. verify that if observer1 will be triggered when put (KEY_1, VALUE_1) to local db.
185      * @tc.expected: step3. observer1 will be response but observer2 won't.
186      */
187     EXPECT_EQ((g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1)), OK);
188     vector<DistributedDB::Entry> insertLocalEntries;
189     insertLocalEntries.push_back(ENTRY_1);
190     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, INSERT_LIST, insertLocalEntries));
191     vector<DistributedDB::Entry> insertNativeEntries;
192     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
193     observerLocal.Clear();
194     /**
195      * @tc.steps: step4. verify that if observer1 will be triggered when delete (KEY_1, VALUE_1) from local db.
196      * @tc.expected: step4. observer1 will be response but observer2 won't.
197      */
198     EXPECT_EQ((g_nbObserverDelegate->DeleteLocal(KEY_1)), OK);
199     vector<DistributedDB::Entry> deleteLocalEntries;
200     deleteLocalEntries.push_back(ENTRY_1);
201     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, DELETE_LIST, deleteLocalEntries));
202     vector<DistributedDB::Entry> deleteNativeEntries;
203     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
204     observerLocal.Clear();
205     /**
206      * @tc.steps: step5. verify that if observer2 will be triggered when put (KEY_1, VALUE_1) to sync db.
207      * @tc.expected: step5. observer2 will be response but observer1 won't.
208      */
209     EXPECT_EQ((g_nbObserverDelegate->Put(KEY_1, VALUE_1)), OK);
210     insertLocalEntries.clear();
211     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
212     insertNativeEntries.clear();
213     insertNativeEntries.push_back(ENTRY_1);
214     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, INSERT_LIST, insertNativeEntries));
215     observerSync.Clear();
216     /**
217      * @tc.steps: step6. verify that if observer2 will be triggered when delete (KEY_1, VALUE_1) from sync db.
218      * @tc.expected: step6. observer1 will be response but observer2 won't.
219      */
220     EXPECT_EQ((g_nbObserverDelegate->Delete(KEY_1)), OK);
221     deleteLocalEntries.clear();
222     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
223     deleteNativeEntries.clear();
224     deleteNativeEntries.push_back(ENTRY_1);
225     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, DELETE_LIST, deleteNativeEntries));
226     observerSync.Clear();
227     g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
228     g_nbObserverDelegate->UnRegisterObserver(&observerSync);
229 }
230 
CheckObserverAllLocalValue(KvStoreObserverImpl & observerLocal)231 void CheckObserverAllLocalValue(KvStoreObserverImpl &observerLocal)
232 {
233     /**
234      * @tc.steps: step2. put one entries (KEY_1, VALUE_1) to local db.
235      * @tc.expected: step2. observerLocal will be response and the data observerLocal got is (KEY_1, VALUE_1).
236      */
237     DBStatus status = g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
238     EXPECT_EQ(status, OK);
239     vector<DistributedDB::Entry> insertLocalEntries;
240     insertLocalEntries.push_back(ENTRY_1);
241     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, INSERT_LIST, insertLocalEntries));
242     observerLocal.Clear();
243 
244     /**
245      * @tc.steps: step3. update one entries (KEY_2, VALUE_2) of local db.
246      * @tc.expected: step3. observerLocal will be response and the data observerLocal got is (KEY_2, VALUE_2).
247      */
248     status = g_nbObserverDelegate->PutLocal(KEY_2, VALUE_2);
249     EXPECT_EQ(status, OK);
250     insertLocalEntries.clear();
251     insertLocalEntries.push_back(ENTRY_2);
252     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, INSERT_LIST, insertLocalEntries));
253     observerLocal.Clear();
254 
255     /**
256      * @tc.steps: step4. delete one entry of local db where key = KEY_1.
257      * @tc.expected: step4. observerLocal will be response and the data observerLocal got is (KEY_1, VALUE_1).
258      */
259     status = g_nbObserverDelegate->DeleteLocal(KEY_1);
260     EXPECT_EQ(status, OK);
261     vector<DistributedDB::Entry> deleteLocalEntries;
262     deleteLocalEntries.push_back(ENTRY_1);
263     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, DELETE_LIST, deleteLocalEntries));
264     observerLocal.Clear();
265 }
266 
267 /*
268  * @tc.name: RegisterData 002
269  * @tc.desc: Verify that can observer all records of local db.
270  * @tc.type: FUNC
271  * @tc.require: SR000CQDVH
272  * @tc.author: luqianfu
273  */
274 HWTEST_F(DistributeddbNbObserverTest, RegisterData002, TestSize.Level1)
275 {
276     KvStoreObserverImpl observerLocal;
277     KvStoreObserverImpl observerSync;
278     /**
279      * @tc.steps: step1. register local observerLocal use empty key KEY_EMPTY.
280      * @tc.expected: step1. register success.
281      */
282     DBStatus status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
283     EXPECT_EQ(status, OK);
284 
285     CheckObserverAllLocalValue(observerLocal);
286 
287     /**
288      * @tc.steps: step5. put one entry (KEY_1, VALUE_1) to sync db.
289      * @tc.expected: step5. observerLocal won't be response.
290      */
291     status = g_nbObserverDelegate->Put(KEY_1, VALUE_1);
292     EXPECT_EQ(status, OK);
293     vector<DistributedDB::Entry> insertNativeEntries;
294     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
295     observerSync.Clear();
296 
297     /**
298      * @tc.steps: step6. put one entry (KEY_2, VALUE_2) to sync db.
299      * @tc.expected: step6. observerLocal won't be response.
300      */
301     status = g_nbObserverDelegate->Put(KEY_2, VALUE_2);
302     EXPECT_EQ(status, OK);
303     insertNativeEntries.clear();
304     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
305     observerSync.Clear();
306 
307     /**
308      * @tc.steps: step7. delete one entry from sync db where key = KEY_1.
309      * @tc.expected: step7. observerLocal won't be response.
310      */
311     status = g_nbObserverDelegate->Delete(KEY_1);
312     EXPECT_EQ(status, OK);
313     vector<DistributedDB::Entry> deleteNativeEntries;
314     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
315     observerSync.Clear();
316 
317     g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
318     g_nbObserverDelegate->DeleteLocal(KEY_2);
319     g_nbObserverDelegate->Delete(KEY_2);
320 }
321 
CheckObserverAllNativeValue(KvStoreObserverImpl & observerLocal,KvStoreObserverImpl & observerSync)322 void CheckObserverAllNativeValue(KvStoreObserverImpl &observerLocal, KvStoreObserverImpl &observerSync)
323 {
324     /**
325      * @tc.steps: step2. put one entries (KEY_1, VALUE_1) to local db.
326      * @tc.expected: step2. observerLocal won't be response.
327      */
328     EXPECT_EQ(g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1), OK);
329     vector<DistributedDB::Entry> insertLocalEntries;
330     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
331     observerLocal.Clear();
332 
333     /**
334      * @tc.steps: step3. update one entries (KEY_2, VALUE_2) of local db.
335      * @tc.expected: step3. observerLocal won't be response.
336      */
337     EXPECT_EQ(g_nbObserverDelegate->PutLocal(KEY_2, VALUE_2), OK);
338     insertLocalEntries.clear();
339     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
340     observerLocal.Clear();
341 
342     /**
343      * @tc.steps: step4. delete one entry of local db where key = KEY_1.
344      * @tc.expected: step4. observerLocal won't be response.
345      */
346     EXPECT_EQ(g_nbObserverDelegate->DeleteLocal(KEY_1), OK);
347     vector<DistributedDB::Entry> deleteLocalEntries;
348     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
349     observerLocal.Clear();
350 
351     /**
352      * @tc.steps: step5. put one entry (KEY_1, VALUE_1) to sync db.
353      * @tc.expected: step5. observerSync will be response and the data observerSync got is (KEY_1, VALUE_1).
354      */
355     EXPECT_EQ(g_nbObserverDelegate->Put(KEY_1, VALUE_1), OK);
356     vector<DistributedDB::Entry> insertNativeEntries;
357     insertNativeEntries.push_back(ENTRY_1);
358     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, INSERT_LIST, insertNativeEntries));
359     observerSync.Clear();
360 
361     /**
362      * @tc.steps: step6. update one entry (KEY_2, VALUE_3) to sync db.
363      * @tc.expected: step6. observerSync will be response and the data observerSync got is (KEY_2, VALUE_3).
364      */
365     EXPECT_EQ(g_nbObserverDelegate->Put(KEY_2, VALUE_3), OK);
366     insertNativeEntries.clear();
367     insertNativeEntries.push_back(ENTRY_2_3);
368     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, INSERT_LIST, insertNativeEntries));
369     observerSync.Clear();
370 }
371 
372 /*
373  * @tc.name: RegisterData 003
374  * @tc.desc: Verify that can observer all records of sync db.
375  * @tc.type: FUNC
376  * @tc.require: SR000CQDVH
377  * @tc.author: luqianfu
378  */
379 HWTEST_F(DistributeddbNbObserverTest, RegisterData003, TestSize.Level1)
380 {
381     KvStoreObserverImpl observerLocal;
382     KvStoreObserverImpl observerSync;
383     /**
384      * @tc.steps: step1. register sync observerSync use empty key KEY_EMPTY.
385      * @tc.expected: step1. register success.
386      */
387     DBStatus status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_NATIVE, &observerSync);
388     EXPECT_EQ(status, OK);
389 
390     CheckObserverAllNativeValue(observerLocal, observerSync);
391 
392     status = g_nbObserverDelegate->Put(KEY_2, VALUE_2);
393     vector<DistributedDB::Entry> updateNativeEntries;
394     updateNativeEntries.push_back(ENTRY_2);
395     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, UPDATE_LIST, updateNativeEntries));
396     observerSync.Clear();
397 
398     EXPECT_EQ(g_nbObserverDelegate->Put(KEY_2, VALUE_3), OK);
399     updateNativeEntries.clear();
400     updateNativeEntries.push_back(ENTRY_2_3);
401     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, UPDATE_LIST, updateNativeEntries));
402     observerSync.Clear();
403 
404     /**
405      * @tc.steps: step7. delete one entry from sync db where key = KEY_1.
406      * @tc.expected: step7. observerSync will be response and the data observerSync got is (KEY_1, VALUE_1).
407      */
408     EXPECT_EQ(g_nbObserverDelegate->Delete(KEY_1), OK);
409     vector<DistributedDB::Entry> deleteNativeEntries;
410     deleteNativeEntries.push_back(ENTRY_1);
411     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, DELETE_LIST, deleteNativeEntries));
412     observerSync.Clear();
413 
414     g_nbObserverDelegate->UnRegisterObserver(&observerSync);
415     g_nbObserverDelegate->DeleteLocal(KEY_2);
416     g_nbObserverDelegate->Delete(KEY_2);
417 }
418 
419 /*
420  * @tc.name: UnRegister 001
421  * @tc.desc: Verify that the record didn't register won't trigger the observer.
422  * @tc.type: FUNC
423  * @tc.require: SR000CCPOI
424  * @tc.author: luqianfu
425  */
426 HWTEST_F(DistributeddbNbObserverTest, UnRegister001, TestSize.Level1)
427 {
428     KvStoreObserverImpl observerLocal;
429     KvStoreObserverImpl observerSync;
430     /**
431      * @tc.steps: step1. register local observerLocal use key = KEY_1.
432      * @tc.expected: step1. register success.
433      */
434     DBStatus status =
435         g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
436     EXPECT_EQ(status, OK);
437     /**
438      * @tc.steps: step2. register sync observerSync use  key = KEY_2.
439      * @tc.expected: step2. register success.
440      */
441     status = g_nbObserverDelegate->RegisterObserver(KEY_2, OBSERVER_CHANGES_NATIVE, &observerSync);
442     EXPECT_EQ(status, OK);
443     /**
444      * @tc.steps: step3. put one entries (KEY_2, VALUE_2) to local db.
445      * @tc.expected: step3. observerLocal won't be response and observerSync won't be response.
446      */
447     EXPECT_EQ(g_nbObserverDelegate->PutLocal(KEY_2, VALUE_2), OK);
448     vector<DistributedDB::Entry> insertLocalEntries;
449     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
450     vector<DistributedDB::Entry> insertNativeEntries;
451     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
452     observerLocal.Clear();
453 
454     /**
455      * @tc.steps: step4. delete one entries from local db where key = KEY_2.
456      * @tc.expected: step4. observerLocal won't be response and observerSync won't be response.
457      */
458     EXPECT_EQ(g_nbObserverDelegate->DeleteLocal(KEY_2), OK);
459     vector<DistributedDB::Entry> deleteLocalEntries;
460     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
461     vector<DistributedDB::Entry> deleteNativeEntries;
462     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
463     observerLocal.Clear();
464 
465     /**
466      * @tc.steps: step5. put one entries (KEY_1, VALUE_1) to sync db.
467      * @tc.expected: step5. observerLocal won't be response and observerSync won't be response.
468      */
469     EXPECT_EQ(g_nbObserverDelegate->Put(KEY_1, VALUE_1), OK);
470     insertLocalEntries.clear();
471     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
472     insertNativeEntries.clear();
473     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
474     observerSync.Clear();
475 
476     /**
477      * @tc.steps: step6. delete one entries from sync db where key = KEY_1.
478      * @tc.expected: step6. observerLocal won't be response and observerSync won't be response.
479      */
480     EXPECT_EQ(g_nbObserverDelegate->Delete(KEY_1), OK);
481     deleteLocalEntries.clear();
482     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
483     deleteNativeEntries.clear();
484     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
485     observerSync.Clear();
486     g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
487     g_nbObserverDelegate->UnRegisterObserver(&observerSync);
488 }
489 
490 /*
491  * @tc.name: UnRegister 002
492  * @tc.desc: Verify that UnRegister local of KEY_1 observer and sync observer won't be affected.
493  * @tc.type: FUNC
494  * @tc.require: SR000CCPOI
495  * @tc.author: luqianfu
496  */
497 HWTEST_F(DistributeddbNbObserverTest, UnRegister002, TestSize.Level1)
498 {
499     KvStoreObserverImpl observerLocal;
500     KvStoreObserverImpl observerSync;
501     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
502     g_nbObserverDelegate->Put(KEY_1, VALUE_1);
503     DBStatus status =
504         g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
505     EXPECT_EQ(status, OK);
506     status = g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_NATIVE, &observerSync);
507     EXPECT_EQ(status, OK);
508     /**
509      * @tc.steps: step1. UnRegister local observer of KEY_1.
510      * @tc.expected: step1. UnRegister success.
511      */
512     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
513     EXPECT_EQ(status, OK);
514     /**
515      * @tc.steps: step2. delete one entries from local db where key = KEY_1.
516      * @tc.expected: step2. observerLocal won't be response and observerSync won't be response.
517      */
518     EXPECT_EQ(g_nbObserverDelegate->DeleteLocal(KEY_1), OK);
519     vector<DistributedDB::Entry> deleteLocalEntries, deleteNativeEntries;
520     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
521     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
522     observerLocal.Clear();
523 
524     /**
525      * @tc.steps: step3. delete one entries from sync db where key = KEY_1.
526      * @tc.expected: step3. observerLocal won't be response but observerSync will be response
527      *    and got record (KEY_1, VALUE_1).
528      */
529     EXPECT_EQ(g_nbObserverDelegate->Delete(KEY_1), OK);
530     deleteNativeEntries.clear();
531     deleteNativeEntries.push_back(ENTRY_1);
532     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, DELETE_LIST, deleteNativeEntries));
533     deleteLocalEntries.clear();
534     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
535     observerSync.Clear();
536     g_nbObserverDelegate->UnRegisterObserver(&observerSync);
537 }
538 
539 /*
540  * @tc.name: UnRegister 003
541  * @tc.desc: Verify that UnRegister sync observer of KEY_1 and local observer won't be affected.
542  * @tc.type: FUNC
543  * @tc.require: SR000CCPOI
544  * @tc.author: luqianfu
545  */
546 HWTEST_F(DistributeddbNbObserverTest, UnRegister003, TestSize.Level1)
547 {
548     KvStoreObserverImpl observerLocal;
549     KvStoreObserverImpl observerSync;
550     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
551     g_nbObserverDelegate->Put(KEY_1, VALUE_1);
552     DBStatus status =
553         g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
554     EXPECT_TRUE(status == OK);
555     status = g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_NATIVE, &observerSync);
556     EXPECT_TRUE(status == OK);
557     /**
558      * @tc.steps: step1. UnRegister sync observer of KEY_1.
559      * @tc.expected: step1. UnRegister success.
560      */
561     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
562     EXPECT_TRUE(status == OK);
563     /**
564      * @tc.steps: step2. delete one entries from local db where key = KEY_1.
565      * @tc.expected: step2. observerLocal will be response and got record (KEY_1, VALUE_1)
566      *    but observerSync won't be response.
567      */
568     EXPECT_TRUE(g_nbObserverDelegate->DeleteLocal(KEY_1) == OK);
569     vector<DistributedDB::Entry> deleteLocalEntry;
570     deleteLocalEntry.push_back(ENTRY_1);
571     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, DELETE_LIST, deleteLocalEntry));
572     vector<DistributedDB::Entry> deleteNativeEntry;
573     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntry));
574     observerLocal.Clear();
575 
576     /**
577      * @tc.steps: step3. delete one entries from sync db where key = KEY_1.
578      * @tc.expected: step3. observerLocal won't be response and observerSync won't be response.
579      */
580     EXPECT_TRUE(g_nbObserverDelegate->Delete(KEY_1) == OK);
581     deleteLocalEntry.clear();
582     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntry));
583     deleteNativeEntry.clear();
584     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntry));
585     observerSync.Clear();
586     g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
587 }
588 
589 /*
590  * @tc.name: UnRegister 004
591  * @tc.desc: Verify that UnRegister local observer of all-key and sync observer won't be affected.
592  * @tc.type: FUNC
593  * @tc.require: SR000CCPOI
594  * @tc.author: luqianfu
595  */
596 HWTEST_F(DistributeddbNbObserverTest, UnRegister004, TestSize.Level1)
597 {
598     KvStoreObserverImpl observerLocal;
599     KvStoreObserverImpl observerSync;
600     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
601     g_nbObserverDelegate->Put(KEY_1, VALUE_1);
602     DBStatus status =
603         g_nbObserverDelegate->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
604     EXPECT_EQ(status, OK);
605     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_NATIVE, &observerSync);
606     EXPECT_EQ(status, OK);
607     /**
608      * @tc.steps: step1. UnRegister local observer of KEY_EMPTY.
609      * @tc.expected: step1. UnRegister success.
610      */
611     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
612     EXPECT_EQ(status, OK);
613     /**
614      * @tc.steps: step2. delete one entries from local db where key = KEY_1.
615      * @tc.expected: step2. observerLocal won't be response but observerSync won't be response.
616      */
617     EXPECT_EQ(g_nbObserverDelegate->DeleteLocal(KEY_1), OK);
618     vector<DistributedDB::Entry> insertLocalEntries;
619     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
620     vector<DistributedDB::Entry> insertNativeEntries;
621     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
622     observerLocal.Clear();
623 
624     /**
625      * @tc.steps: step3. delete one entries from sync db where key = KEY_1.
626      * @tc.expected: step3. observerLocal won't be response but observerSync will be response
627      *    and got record (KEY_1, VALUE_1).
628      */
629     EXPECT_EQ(g_nbObserverDelegate->Delete(KEY_1), OK);
630     vector<DistributedDB::Entry> deleteLocalEntries;
631     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
632     vector<DistributedDB::Entry> deleteNativeEntries;
633     deleteNativeEntries.push_back(ENTRY_1);
634     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, DELETE_LIST, deleteNativeEntries));
635     observerSync.Clear();
636     g_nbObserverDelegate->UnRegisterObserver(&observerSync);
637 }
638 
639 /*
640  * @tc.name: UnRegister 005
641  * @tc.desc: Verify that UnRegister sync observer of all-key and local observer won't be affected.
642  * @tc.type: FUNC
643  * @tc.require: SR000CCPOI
644  * @tc.author: luqianfu
645  */
646 HWTEST_F(DistributeddbNbObserverTest, UnRegister005, TestSize.Level1)
647 {
648     KvStoreObserverImpl observerLocal;
649     KvStoreObserverImpl observerSync;
650     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
651     g_nbObserverDelegate->Put(KEY_1, VALUE_1);
652     DBStatus status =
653         g_nbObserverDelegate->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
654     EXPECT_EQ(status, OK);
655     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_NATIVE, &observerSync);
656     EXPECT_EQ(status, OK);
657     /**
658      * @tc.steps: step1. UnRegister sync observer of KEY_EMPTY.
659      * @tc.expected: step1. UnRegister success.
660      */
661     EXPECT_EQ(g_nbObserverDelegate->UnRegisterObserver(&observerSync), OK);
662     /**
663      * @tc.steps: step2. delete one entries from local db where key = KEY_1.
664      * @tc.expected: step2. observerLocal will be response and got record (KEY_1, VALUE_1)
665      *    but observerSync won't be response.
666      */
667     EXPECT_EQ(g_nbObserverDelegate->DeleteLocal(KEY_1), OK);
668     vector<DistributedDB::Entry> deleteLocalEntries;
669     deleteLocalEntries.push_back(ENTRY_1);
670     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, DELETE_LIST, deleteLocalEntries));
671     vector<DistributedDB::Entry> deleteNativeEntries;
672     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
673     observerLocal.Clear();
674 
675     /**
676      * @tc.steps: step3. delete one entries from sync db where key = KEY_1.
677      * @tc.expected: step3. observerLocal won't be response and observerSync won't be response.
678      */
679     EXPECT_EQ(g_nbObserverDelegate->Delete(KEY_1), OK);
680     deleteLocalEntries.clear();
681     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
682     observerSync.Clear();
683     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
684     deleteNativeEntries.clear();
685     g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
686 }
687 
688 /*
689  * @tc.name: ParamCheck 001
690  * @tc.desc: Verify that can check effectiveness of params mode.
691  * @tc.type: FUNC
692  * @tc.require: SR000CCPOI
693  * @tc.author: luqianfu
694  */
695 HWTEST_F(DistributeddbNbObserverTest, ParamCheck001, TestSize.Level1)
696 {
697     KvStoreObserverImpl observer1, observer2, observer3, observer4, observer;
698 
699     DBStatus status =
700         g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_LOCAL_ONLY, &observer1);
701     EXPECT_EQ(status, OK);
702     status = g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_NATIVE, &observer2);
703     EXPECT_EQ(status, OK);
704     status = g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_FOREIGN, &observer3);
705     EXPECT_EQ(status, OK);
706     status = g_nbObserverDelegate->RegisterObserver(KEY_1,
707         OBSERVER_CHANGES_FOREIGN | OBSERVER_CHANGES_NATIVE, &observer4);
708     EXPECT_EQ(status, OK);
709     /**
710      * @tc.steps: step1. Register observer with the mode is not in (1, 2, 3, 4).
711      * @tc.expected: step1. Register failed and return INVALID_ARGS.
712      */
713     status = g_nbObserverDelegate->RegisterObserver(KEY_1, 0, &observer); // invalid mode number 0
714     EXPECT_EQ(status, INVALID_ARGS);
715     status = g_nbObserverDelegate->RegisterObserver(KEY_1, 5, &observer); // invalid mode number 5
716     EXPECT_EQ(status, INVALID_ARGS);
717     status = g_nbObserverDelegate->RegisterObserver(KEY_1, -1, &observer); // invalid mode number -1
718     EXPECT_EQ(status, INVALID_ARGS);
719     status = g_nbObserverDelegate->RegisterObserver(KEY_1, 2147483647, &observer); // invalid mode number 2147483647
720     EXPECT_EQ(status, INVALID_ARGS);
721     status = g_nbObserverDelegate->RegisterObserver(KEY_1, -2147483648, &observer); // invalid mode number -2147483648
722     EXPECT_EQ(status, INVALID_ARGS);
723     status = g_nbObserverDelegate->RegisterObserver(KEY_1, 999, &observer); // invalid mode number 999
724     EXPECT_EQ(status, INVALID_ARGS);
725     g_nbObserverDelegate->UnRegisterObserver(&observer1);
726     g_nbObserverDelegate->UnRegisterObserver(&observer2);
727     g_nbObserverDelegate->UnRegisterObserver(&observer3);
728     g_nbObserverDelegate->UnRegisterObserver(&observer4);
729 }
730 
731 /*
732  * @tc.name: ParamCheck 002
733  * @tc.desc: Verify that can check effectiveness of params key.
734  * @tc.type: FUNC
735  * @tc.require: SR000CCPOI
736  * @tc.author: luqianfu
737  */
738 HWTEST_F(DistributeddbNbObserverTest, ParamCheck002, TestSize.Level1)
739 {
740     DistributedDB::Key eKey1, eKey2, eKey3;
741     eKey1.assign(ONE_K_LONG_STRING, (uint8_t)'a');
742     eKey2.assign(ONE_K_LONG_STRING + 1, (uint8_t)'b');
743     eKey3 = { 'a', 'b', 'c', 'D', 'E', 'F', '2', '4', '5', 199, 1, 255, 0 };
744     KvStoreObserverImpl observer1, observer2, observer3, observer4, observer5, observer6;
745 
746     /**
747      * @tc.steps: step1. Register local observer with the key = eKey1 size of which is 1024.
748      * @tc.expected: step1. Register success.
749      */
750     DBStatus status =
751         g_nbObserverDelegate->RegisterObserver(eKey1, OBSERVER_CHANGES_LOCAL_ONLY, &observer1);
752     EXPECT_EQ(status, OK);
753     /**
754      * @tc.steps: step2. Register local observer with the key = eKey2 size of which is 1025.
755      * @tc.expected: step2. Register failed and return INVALID_ARGS.
756      */
757     status = g_nbObserverDelegate->RegisterObserver(eKey2, OBSERVER_CHANGES_LOCAL_ONLY, &observer2);
758     EXPECT_EQ(status, INVALID_ARGS);
759     /**
760      * @tc.steps: step3. Register local observer with the key = eKey3 which contains
761      *    [a-zA-Z0-9], [\0-\255], chinese and latins.
762      * @tc.expected: step3. Register failed and return INVALID_ARGS.
763      */
764     status = g_nbObserverDelegate->RegisterObserver(eKey3, OBSERVER_CHANGES_LOCAL_ONLY, &observer3);
765     EXPECT_EQ(status, OK);
766     /**
767      * @tc.steps: step4. Register sync observer with the key = eKey1 size of which is 1024.
768      * @tc.expected: step4. Register success.
769      */
770     status = g_nbObserverDelegate->RegisterObserver(eKey1, OBSERVER_CHANGES_NATIVE, &observer4);
771     EXPECT_EQ(status, OK);
772     /**
773      * @tc.steps: step5. Register local observer with the key = eKey2 size of which is 1025.
774      * @tc.expected: step5. Register failed and return INVALID_ARGS.
775      */
776     status = g_nbObserverDelegate->RegisterObserver(eKey2, OBSERVER_CHANGES_NATIVE, &observer5);
777     EXPECT_EQ(status, INVALID_ARGS);
778     /**
779      * @tc.steps: step6. Register local observer with the key = eKey3 which contains
780      *    [a-zA-Z0-9], [\0-\255], chinese and latins.
781      * @tc.expected: step6. Register failed and return INVALID_ARGS.
782      */
783     status = g_nbObserverDelegate->RegisterObserver(eKey3, OBSERVER_CHANGES_NATIVE, &observer6);
784     EXPECT_EQ(status, OK);
785     g_nbObserverDelegate->UnRegisterObserver(&observer1);
786     g_nbObserverDelegate->UnRegisterObserver(&observer2);
787     g_nbObserverDelegate->UnRegisterObserver(&observer3);
788     g_nbObserverDelegate->UnRegisterObserver(&observer4);
789     g_nbObserverDelegate->UnRegisterObserver(&observer5);
790     g_nbObserverDelegate->UnRegisterObserver(&observer6);
791 }
792 
CheckPressureActionInNative(KvStoreObserverImpl & observerLocal,KvStoreObserverImpl & observerSync)793 void CheckPressureActionInNative(KvStoreObserverImpl &observerLocal, KvStoreObserverImpl &observerSync)
794 {
795     /**
796      * @tc.steps: step3. put one entries (KEY_1, VALUE_1) to local db.
797      * @tc.expected: step3. observerLocal won't be response.
798      */
799     DBStatus status = g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
800     EXPECT_EQ(status, OK);
801     vector<DistributedDB::Entry> insertLocalEntries;
802     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
803     vector<DistributedDB::Entry> insertNativeEntries;
804     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
805     observerLocal.Clear();
806 
807     /**
808      * @tc.steps: step4. put one entries (KEY_1, VALUE_1) to sync db.
809      * @tc.expected: step4. observerSync will be response and the data observerSync got is (KEY_1, VALUE_1).
810      */
811     status = g_nbObserverDelegate->Put(KEY_1, VALUE_1);
812     EXPECT_EQ(status, OK);
813     insertLocalEntries.clear();
814     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
815     insertNativeEntries.clear();
816     insertNativeEntries.push_back(ENTRY_1);
817     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, INSERT_LIST, insertNativeEntries));
818     observerSync.Clear();
819 
820     /**
821      * @tc.steps: step5. update one entries (KEY_1, VALUE_2) to local db.
822      * @tc.expected: step5. observerLocal won't be response.
823      */
824     status = g_nbObserverDelegate->PutLocal(KEY_1, VALUE_2);
825     EXPECT_EQ(status, OK);
826     vector<DistributedDB::Entry> updateLocalEntries;
827     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, updateLocalEntries));
828     vector<DistributedDB::Entry> updateNativeEntries;
829     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, updateNativeEntries));
830     observerLocal.Clear();
831 
832     /**
833      * @tc.steps: step6. update one entries (KEY_1, VALUE_2) to sync db.
834      * @tc.expected: step6. observerSync will be response and the data observerSync got is (KEY_1, VALUE_2).
835      */
836     status = g_nbObserverDelegate->Put(KEY_1, VALUE_2);
837     EXPECT_EQ(status, OK);
838     updateLocalEntries.clear();
839     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, updateLocalEntries));
840     updateNativeEntries.clear();
841     updateNativeEntries.push_back(ENTRY_1_2);
842     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, UPDATE_LIST, updateNativeEntries));
843     observerSync.Clear();
844 }
845 
846 /*
847  * @tc.name: Pressure 001
848  * @tc.desc: Verify that local db can observer the key that do not exist.
849  * @tc.type: FUNC
850  * @tc.require: SR000CCPOI
851  * @tc.author: luqianfu
852  */
853 HWTEST_F(DistributeddbNbObserverTest, Pressure001, TestSize.Level1)
854 {
855     KvStoreObserverImpl observerLocal;
856     KvStoreObserverImpl observerSync;
857 
858     /**
859      * @tc.steps: step1. Register local observer with the key = KEY_A_1 which do not exist in db.
860      * @tc.expected: step1. Register success.
861      */
862     DBStatus status =
863         g_nbObserverDelegate->RegisterObserver(KEY_A_1, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
864     EXPECT_EQ(status, OK);
865     /**
866      * @tc.steps: step2. Register sync observer with the key = KEY_EMPTY.
867      * @tc.expected: step2. Register success.
868      */
869     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
870         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
871     EXPECT_EQ(status, OK);
872 
873     CheckPressureActionInNative(observerLocal, observerSync);
874 
875     /**
876      * @tc.steps: step7. delete one entries from local db where key = KEY_1.
877      * @tc.expected: step7. observerLocal won't be response.
878      */
879     status = g_nbObserverDelegate->DeleteLocal(KEY_1);
880     EXPECT_EQ(status, OK);
881     vector<DistributedDB::Entry> deleteLocalEntries;
882     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
883     vector<DistributedDB::Entry> deleteNativeEntries;
884     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
885     observerLocal.Clear();
886 
887     /**
888      * @tc.steps: step8. delete one entries from sync db where key = KEY_1.
889      * @tc.expected: step8. observerLocal won't be response but observerSync will be response and
890      *     the data observerSync got is (KEY_1, VALUE_2).
891      */
892     status = g_nbObserverDelegate->Delete(KEY_1);
893     EXPECT_EQ(status, OK);
894     deleteLocalEntries.clear();
895     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
896     deleteNativeEntries.clear();
897     deleteNativeEntries.push_back(ENTRY_1_2);
898     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, DELETE_LIST, deleteNativeEntries));
899     observerSync.Clear();
900 
901     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
902     EXPECT_EQ(status, OK);
903     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
904     EXPECT_EQ(status, OK);
905 }
906 
CheckPressureActionInLocal(KvStoreObserverImpl & observerLocal,KvStoreObserverImpl & observerSync)907 void CheckPressureActionInLocal(KvStoreObserverImpl &observerLocal, KvStoreObserverImpl &observerSync)
908 {
909     /**
910      * @tc.steps: step3. put one entries (KEY_1, VALUE_1) to local db.
911      * @tc.expected: step3. observerLocal will be response and the data observerLocal got is (KEY_1, VALUE_1).
912      */
913     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
914     vector<DistributedDB::Entry> insertLocalEntry;
915     insertLocalEntry.push_back(ENTRY_1);
916     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, INSERT_LIST, insertLocalEntry));
917     vector<DistributedDB::Entry> insertNativeEntry;
918     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntry));
919     observerLocal.Clear();
920 
921     /**
922      * @tc.steps: step4. put one entries (KEY_1, VALUE_1) to sync db.
923      * @tc.expected: step4. observerLocal won't be response.
924      */
925     g_nbObserverDelegate->Put(KEY_1, VALUE_1);
926     insertLocalEntry.clear();
927     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntry));
928     insertNativeEntry.clear();
929     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntry));
930     observerSync.Clear();
931 
932     /**
933      * @tc.steps: step5. update one entries (KEY_1, VALUE_2) to local db.
934      * @tc.expected: step5. observerLocal will be response and the data observerLocal got is (KEY_1, VALUE_2).
935      */
936     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_2);
937     vector<DistributedDB::Entry> updateLocalEntry;
938     updateLocalEntry.push_back(ENTRY_1_2);
939     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, UPDATE_LIST, updateLocalEntry));
940     vector<DistributedDB::Entry> updateNativeEntry;
941     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, updateNativeEntry));
942     observerLocal.Clear();
943 
944     /**
945      * @tc.steps: step6. update one entries (KEY_1, VALUE_2) to sync db.
946      * @tc.expected: step6. observerSync won't be response.
947      */
948     g_nbObserverDelegate->Put(KEY_1, VALUE_2);
949     updateLocalEntry.clear();
950     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, updateLocalEntry));
951     updateNativeEntry.clear();
952     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, updateNativeEntry));
953     observerSync.Clear();
954 }
955 
956 /*
957  * @tc.name: Pressure 002
958  * @tc.desc: Verify that sync db can observer the key that do not exist.
959  * @tc.type: FUNC
960  * @tc.require: SR000CCPOI
961  * @tc.author: luqianfu
962  */
963 HWTEST_F(DistributeddbNbObserverTest, Pressure002, TestSize.Level1)
964 {
965     KvStoreObserverImpl observerLocal;
966     KvStoreObserverImpl observerSync;
967 
968     /**
969      * @tc.steps: step1. Register local observer with the key = KEY_EMPTY.
970      * @tc.expected: step1. Register success.
971      */
972     DBStatus status =
973         g_nbObserverDelegate->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
974     EXPECT_EQ(status, OK);
975     /**
976      * @tc.steps: step2. Register sync observer with the key = KEY_A_1 which do not exist in db.
977      * @tc.expected: step2. Register success.
978      */
979     status = g_nbObserverDelegate->RegisterObserver(KEY_A_1, OBSERVER_CHANGES_NATIVE, &observerSync);
980     EXPECT_EQ(status, OK);
981 
982     CheckPressureActionInLocal(observerLocal, observerSync);
983 
984     /**
985      * @tc.steps: step7. delete one entries from local db where key = KEY_1.
986      * @tc.expected: step7. observerLocal will be response and the data observerLocal got is (KEY_1, VALUE_2)
987      *    but observerSync won't be response.
988      */
989     status = g_nbObserverDelegate->DeleteLocal(KEY_1);
990     EXPECT_EQ(status, OK);
991     vector<DistributedDB::Entry> deleteLocalEntries;
992     DistributedDB::Entry entry = { KEY_1, VALUE_2 };
993     deleteLocalEntries.push_back(entry);
994     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, DELETE_LIST, deleteLocalEntries));
995     vector<DistributedDB::Entry> deleteNativeEntries;
996     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
997     observerLocal.Clear();
998 
999     /**
1000      * @tc.steps: step8. delete one entries from sync db where key = KEY_1.
1001      * @tc.expected: step8. observerSync won't be response.
1002      */
1003     status = g_nbObserverDelegate->Delete(KEY_1);
1004     EXPECT_EQ(status, OK);
1005     deleteNativeEntries.clear();
1006     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
1007     deleteLocalEntries.clear();
1008     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
1009     observerSync.Clear();
1010     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1011     EXPECT_EQ(status, OK);
1012     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1013     EXPECT_EQ(status, OK);
1014 }
1015 
1016 /*
1017  * @tc.name: Pressure 003
1018  * @tc.desc: Verify that can't unregister observer that do not exist.
1019  * @tc.type: FUNC
1020  * @tc.require: SR000CCPOI
1021  * @tc.author: luqianfu
1022  */
1023 HWTEST_F(DistributeddbNbObserverTest, Pressure003, TestSize.Level1)
1024 {
1025     KvStoreObserverImpl observerLocal;
1026     KvStoreObserverImpl observerSync;
1027 
1028     /**
1029      * @tc.steps: step1. UnRegister local and sync Observer.
1030      * @tc.expected: step1. it will be both failed to unregister observerLocal and observerSync.
1031      */
1032     DBStatus status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1033     EXPECT_EQ(status, NOT_FOUND);
1034 
1035     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1036     EXPECT_EQ(status, NOT_FOUND);
1037 }
1038 
1039 /*
1040  * @tc.name: Pressure 004
1041  * @tc.desc: Verify that can't unregister nullptr.
1042  * @tc.type: FUNC
1043  * @tc.require: SR000CCPOI
1044  * @tc.author: luqianfu
1045  */
1046 HWTEST_F(DistributeddbNbObserverTest, Pressure004, TestSize.Level1)
1047 {
1048     /**
1049      * @tc.steps: step1. UnRegister nullpter.
1050      * @tc.expected: step1. it will be failed to unregister nullptr and return INVALID_ARGS.
1051      */
1052     DBStatus status = g_nbObserverDelegate->UnRegisterObserver(nullptr);
1053 
1054     EXPECT_EQ(status, INVALID_ARGS);
1055 }
1056 
CheckPressureActionAfterUnregister(KvStoreObserverImpl & observerLocal,KvStoreObserverImpl & observerSync)1057 void CheckPressureActionAfterUnregister(KvStoreObserverImpl &observerLocal, KvStoreObserverImpl &observerSync)
1058 {
1059     /**
1060      * @tc.steps: step4. Crud to local and sync db.
1061      * @tc.expected: step4. Both observerLocal and observerSync won't be response.
1062      */
1063     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
1064     vector<DistributedDB::Entry> insertLocalEntries;
1065     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
1066     vector<DistributedDB::Entry> insertNativeEntries;
1067     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
1068     observerLocal.Clear();
1069 
1070     g_nbObserverDelegate->Put(KEY_1, VALUE_1);
1071     insertLocalEntries.clear();
1072     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
1073     insertNativeEntries.clear();
1074     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
1075     observerSync.Clear();
1076 
1077     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_2);
1078     vector<DistributedDB::Entry> updateNativeEntries;
1079     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, updateNativeEntries));
1080     vector<DistributedDB::Entry> updateLocalEntries;
1081     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, updateLocalEntries));
1082     observerLocal.Clear();
1083 
1084     g_nbObserverDelegate->Put(KEY_1, VALUE_2);
1085     updateNativeEntries.clear();
1086     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, updateNativeEntries));
1087     updateLocalEntries.clear();
1088     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, updateLocalEntries));
1089     observerSync.Clear();
1090 
1091     DBStatus status = g_nbObserverDelegate->DeleteLocal(KEY_1);
1092     EXPECT_EQ(status, OK);
1093     vector<DistributedDB::Entry> deleteLocalEntries;
1094     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
1095     vector<DistributedDB::Entry> deleteNativeEntries;
1096     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
1097     observerLocal.Clear();
1098 }
1099 
1100 /*
1101  * @tc.name: Pressure 005
1102  * @tc.desc: Verify that can't unregister observer repeatedly.
1103  * @tc.type: FUNC
1104  * @tc.require: SR000CCPOI
1105  * @tc.author: luqianfu
1106  */
1107 HWTEST_F(DistributeddbNbObserverTest, Pressure005, TestSize.Level1)
1108 {
1109     KvStoreObserverImpl observerLocal;
1110     KvStoreObserverImpl observerSync;
1111 
1112     DBStatus status =
1113         g_nbObserverDelegate->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1114     EXPECT_EQ(status, OK);
1115     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1116         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1117     EXPECT_EQ(status, OK);
1118 
1119     /**
1120      * @tc.steps: step1. UnRegister local and sync observer the first time.
1121      * @tc.expected: step1. it will be both success to unregister observerLocal and observerSync.
1122      */
1123     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1124     EXPECT_EQ(status, OK);
1125     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1126     EXPECT_EQ(status, OK);
1127 
1128     /**
1129      * @tc.steps: step2. UnRegister local and sync observer the second time.
1130      * @tc.expected: step2. both failed to unregister observerLocal and observerSync, and return NOT_FOUND.
1131      */
1132     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1133     EXPECT_EQ(status, NOT_FOUND);
1134     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1135     EXPECT_EQ(status, NOT_FOUND);
1136 
1137     /**
1138      * @tc.steps: step3. UnRegister local and sync observer the third time.
1139      * @tc.expected: step3. both failed to unregister observerLocal and observerSync, and return NOT_FOUND.
1140      */
1141     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1142     EXPECT_EQ(status, NOT_FOUND);
1143     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1144     EXPECT_EQ(status, NOT_FOUND);
1145 
1146     CheckPressureActionAfterUnregister(observerLocal, observerSync);
1147 
1148     status = g_nbObserverDelegate->Delete(KEY_1);
1149     EXPECT_EQ(status, OK);
1150     vector<DistributedDB::Entry> deleteLocalEntries;
1151     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
1152     vector<DistributedDB::Entry> deleteNativeEntries;
1153     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
1154     observerSync.Clear();
1155 }
1156 
1157 /*
1158  * @tc.name: Pressure 006
1159  * @tc.desc: Verify that can register and unregister observer repeatedly.
1160  * @tc.type: FUNC
1161  * @tc.require: SR000CCPOI
1162  * @tc.author: luqianfu
1163  */
1164 HWTEST_F(DistributeddbNbObserverTest, Pressure006, TestSize.Level1)
1165 {
1166     KvStoreObserverImpl observerLocal;
1167     KvStoreObserverImpl observerSync;
1168     DBStatus status = g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
1169     EXPECT_EQ(status, OK);
1170     status = g_nbObserverDelegate->Put(KEY_1, VALUE_1);
1171     EXPECT_EQ(status, OK);
1172 
1173     /**
1174      * @tc.steps: step1. Register and UnRegister the observer repeatedly.
1175      * @tc.expected: step1. Register and unregister observerLocal and observerSync success each time.
1176      */
1177     for (unsigned int opCnt = NB_OPERATION_CNT_START; opCnt < NB_OPERATION_CNT_END; ++opCnt) {
1178         status = g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1179         EXPECT_EQ(status, OK);
1180         status = g_nbObserverDelegate->RegisterObserver(KEY_1,
1181             OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1182         EXPECT_EQ(status, OK);
1183 
1184         status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1185         EXPECT_EQ(status, OK);
1186         status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1187         EXPECT_EQ(status, OK);
1188     }
1189 
1190     status = g_nbObserverDelegate->DeleteLocal(KEY_1);
1191     EXPECT_EQ(status, OK);
1192     status = g_nbObserverDelegate->Delete(KEY_1);
1193     EXPECT_EQ(status, OK);
1194 }
1195 
CheckPressureForRepeatAction(KvStoreObserverImpl & observerLocal,KvStoreObserverImpl & observerSync)1196 void CheckPressureForRepeatAction(KvStoreObserverImpl &observerLocal, KvStoreObserverImpl &observerSync)
1197 {
1198     /**
1199      * @tc.steps: step2. crud KEY_1 of local and sync db.
1200      * @tc.expected: step2. observerLocal and observerSync can response each time.
1201      */
1202     DBStatus status = g_nbObserverDelegate->PutLocal(KEY_1, VALUE_2);
1203     EXPECT_EQ(status, OK);
1204     vector<DistributedDB::Entry> updateLocalEntries;
1205     updateLocalEntries.push_back(ENTRY_1_2);
1206     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, UPDATE_LIST, updateLocalEntries));
1207     vector<DistributedDB::Entry> updateNativeEntries;
1208     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, updateNativeEntries));
1209     observerLocal.Clear();
1210 
1211     status = g_nbObserverDelegate->Put(KEY_1, VALUE_2);
1212     EXPECT_EQ(status, OK);
1213     updateLocalEntries.clear();
1214     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, updateLocalEntries));
1215     updateNativeEntries.clear();
1216     updateNativeEntries.push_back(ENTRY_1_2);
1217     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, UPDATE_LIST, updateNativeEntries));
1218     observerSync.Clear();
1219 
1220     vector<DistributedDB::Entry> deleteLocalEntries;
1221     vector<DistributedDB::Entry> deleteNativeEntries;
1222     status = g_nbObserverDelegate->DeleteLocal(KEY_1);
1223     EXPECT_EQ(status, OK);
1224     deleteLocalEntries.push_back(ENTRY_1_2);
1225     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, DELETE_LIST, deleteLocalEntries));
1226     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
1227     observerLocal.Clear();
1228 
1229     status = g_nbObserverDelegate->Delete(KEY_1);
1230     EXPECT_EQ(status, OK);
1231 
1232     deleteNativeEntries.push_back(ENTRY_1_2);
1233     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, DELETE_LIST, deleteNativeEntries));
1234     deleteLocalEntries.clear();
1235     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
1236     observerSync.Clear();
1237 }
1238 
1239 /*
1240  * @tc.name: Pressure 007
1241  * @tc.desc: Verify that can't register an observer of the same key repeatedly without unrigister.
1242  * @tc.type: FUNC
1243  * @tc.require: SR000CCPOI
1244  * @tc.author: luqianfu
1245  */
1246 HWTEST_F(DistributeddbNbObserverTest, Pressure007, TestSize.Level1)
1247 {
1248     KvStoreObserverImpl observerLocal, observerSync;
1249     DBStatus status = g_nbObserverDelegate->Put(KEY_1, VALUE_1);
1250     EXPECT_EQ(status, OK);
1251     status = g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
1252     EXPECT_EQ(status, OK);
1253     /**
1254      * @tc.steps: step1. Register a local and a sync observer of one same key KEY_EMPTY 5 times separately.
1255      * @tc.expected: step1. Register observerLocal and observerSync success first time and failed later.
1256      */
1257     for (unsigned int opCnt = NB_OPERATION_CNT_START; opCnt < NB_OPERATION_CNT_END; ++opCnt) {
1258         status = g_nbObserverDelegate->RegisterObserver(KEY_1, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1259         if (opCnt == NB_OPERATION_CNT_START) {
1260             EXPECT_EQ(status, OK);
1261         } else {
1262             EXPECT_EQ(status, ALREADY_SET);
1263         }
1264         status = g_nbObserverDelegate->RegisterObserver(KEY_1,
1265             OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1266         if (opCnt == NB_OPERATION_CNT_START) {
1267             EXPECT_EQ(status, OK);
1268         } else {
1269             EXPECT_EQ(status, ALREADY_SET);
1270         }
1271     }
1272 
1273     CheckPressureForRepeatAction(observerLocal, observerSync);
1274 
1275     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1276     EXPECT_EQ(status, OK);
1277     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1278     EXPECT_EQ(status, OK);
1279 }
1280 
CheckPressureForLocalRepeat(KvStoreObserverImpl & observerLocal,KvStoreObserverImpl & observerSync,vector<vector<DistributedDB::Entry>> & entries)1281 void CheckPressureForLocalRepeat(KvStoreObserverImpl &observerLocal, KvStoreObserverImpl &observerSync,
1282     vector< vector<DistributedDB::Entry> > &entries)
1283 {
1284     /**
1285      * @tc.steps: step2. Crud on local db.
1286      * @tc.expected: step2. Each operator observerLocal response one time.
1287      */
1288     DBStatus status = g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
1289     EXPECT_EQ(status, OK);
1290 
1291     DistributedDB::Entry entry = { KEY_1, VALUE_1 };
1292     entries[INSERT_LOCAL].push_back(entry);
1293     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, INSERT_LIST, entries[INSERT_LOCAL]));
1294     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_NATIVE]));
1295     observerLocal.Clear();
1296 
1297     status = g_nbObserverDelegate->PutLocal(KEY_1, VALUE_2);
1298     EXPECT_EQ(status, OK);
1299 
1300     entry.value = VALUE_2;
1301     entries[UPDATE_LOCAL].push_back(entry);
1302     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1303 
1304     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_NATIVE]));
1305     observerLocal.Clear();
1306 
1307     status = g_nbObserverDelegate->DeleteLocal(KEY_1);
1308     EXPECT_EQ(status, OK);
1309     entries[DELETE_LOCAL].push_back(entry);
1310     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, DELETE_LIST, entries[DELETE_LOCAL]));
1311     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_NATIVE]));
1312     observerLocal.Clear();
1313 
1314     /**
1315      * @tc.steps: step3. Crud on sync db.
1316      * @tc.expected: step3. Each operator observerSync won't be response.
1317      */
1318     status = g_nbObserverDelegate->Put(KEY_1, VALUE_1);
1319     EXPECT_EQ(status, OK);
1320     entries[INSERT_LOCAL].clear();
1321     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_LOCAL]));
1322     entries[INSERT_NATIVE].clear();
1323     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_NATIVE]));
1324     observerSync.Clear();
1325 }
1326 
1327 /*
1328  * @tc.name: Pressure 008
1329  * @tc.desc: Verify that can't register a local observer of all key repeatedly.
1330  * @tc.type: FUNC
1331  * @tc.require: SR000CCPOI
1332  * @tc.author: luqianfu
1333  */
1334 HWTEST_F(DistributeddbNbObserverTest, Pressure008, TestSize.Level1)
1335 {
1336     DBStatus status;
1337     KvStoreObserverImpl observerLocal;
1338     KvStoreObserverImpl observerSync;
1339 
1340     /**
1341      * @tc.steps: step1. Register a local observer of key KEY_EMPTY 5 times repeatedly.
1342      * @tc.expected: step1. Register observerLocal success first time and failed later.
1343      */
1344     for (unsigned int opCnt = NB_OPERATION_CNT_START; opCnt < NB_OPERATION_CNT_END; ++opCnt) {
1345         status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1346         if (opCnt == NB_OPERATION_CNT_START) {
1347             EXPECT_EQ(status, OK);
1348         } else {
1349             EXPECT_EQ(status, ALREADY_SET);
1350         }
1351     }
1352 
1353     vector< vector<DistributedDB::Entry> > entries(6); // 6 element
1354     CheckPressureForLocalRepeat(observerLocal, observerSync, entries);
1355 
1356     status = g_nbObserverDelegate->Put(KEY_1, VALUE_2);
1357     EXPECT_EQ(status, OK);
1358     entries[UPDATE_LOCAL].clear();
1359     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1360     entries[UPDATE_NATIVE].clear();
1361     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_NATIVE]));
1362     observerSync.Clear();
1363 
1364     status = g_nbObserverDelegate->Delete(KEY_1);
1365     EXPECT_EQ(status, OK);
1366     entries[DELETE_LOCAL].clear();
1367     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_LOCAL]));
1368     entries[DELETE_NATIVE].clear();
1369     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_NATIVE]));
1370     observerSync.Clear();
1371 
1372     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1373     EXPECT_EQ(status, OK);
1374 }
1375 
CheckPressureForNativeRepeat(KvStoreObserverImpl & observerLocal,KvStoreObserverImpl & observerSync,vector<vector<DistributedDB::Entry>> & entries)1376 void CheckPressureForNativeRepeat(KvStoreObserverImpl &observerLocal, KvStoreObserverImpl &observerSync,
1377     vector< vector<DistributedDB::Entry> > &entries)
1378 {
1379     /**
1380      * @tc.steps: step2. Crud on local db.
1381      * @tc.expected: step2. Each operator observerLocal won't be response.
1382      */
1383     DBStatus status = g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
1384     EXPECT_EQ(status, OK);
1385     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_LOCAL]));
1386     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_NATIVE]));
1387     observerLocal.Clear();
1388 
1389     status = g_nbObserverDelegate->PutLocal(KEY_1, VALUE_2);
1390     EXPECT_EQ(status, OK);
1391     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1392     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_NATIVE]));
1393     observerLocal.Clear();
1394 
1395     status = g_nbObserverDelegate->DeleteLocal(KEY_1);
1396     EXPECT_EQ(status, OK);
1397     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_LOCAL]));
1398     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_NATIVE]));
1399     observerLocal.Clear();
1400 
1401     /**
1402      * @tc.steps: step3. Crud on Sync db.
1403      * @tc.expected: step3. Each operator observerSync will be response one time.
1404      */
1405     status = g_nbObserverDelegate->Put(KEY_1, VALUE_1);
1406     EXPECT_EQ(status, OK);
1407     entries[INSERT_LOCAL].clear();
1408     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_LOCAL]));
1409     entries[INSERT_NATIVE].clear();
1410     entries[INSERT_NATIVE].push_back(ENTRY_1);
1411     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, INSERT_LIST, entries[INSERT_NATIVE]));
1412     observerSync.Clear();
1413 }
1414 
1415 /*
1416  * @tc.name: Pressure 009
1417  * @tc.desc: Verify that register a sync observer of the same key repeatedly.
1418  * @tc.type: FUNC
1419  * @tc.require: SR000CCPOI
1420  * @tc.author: luqianfu
1421  */
1422 HWTEST_F(DistributeddbNbObserverTest, Pressure009, TestSize.Level1)
1423 {
1424     DBStatus status;
1425     KvStoreObserverImpl observerLocal;
1426     KvStoreObserverImpl observerSync;
1427 
1428     /**
1429      * @tc.steps: step1. Register a sync observer of key KEY_EMPTY 5 times repeatedly.
1430      * @tc.expected: step1. Register observerSync success first time and failed later.
1431      */
1432     for (unsigned int opCnt = NB_OPERATION_CNT_START; opCnt < NB_OPERATION_CNT_END; ++opCnt) {
1433         status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1434             OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1435         if (opCnt == NB_OPERATION_CNT_START) {
1436             EXPECT_EQ(status, OK);
1437         } else {
1438             EXPECT_EQ(status, ALREADY_SET);
1439         }
1440     }
1441 
1442     vector< vector<DistributedDB::Entry> > entries(6); // 6 element
1443     CheckPressureForNativeRepeat(observerLocal, observerSync, entries);
1444 
1445     status = g_nbObserverDelegate->Put(KEY_1, VALUE_2);
1446     EXPECT_EQ(status, OK);
1447     entries[UPDATE_LOCAL].clear();
1448     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1449     entries[UPDATE_NATIVE].clear();
1450     DistributedDB::Entry entry = { KEY_1, VALUE_2 };
1451     entries[UPDATE_NATIVE].push_back(entry);
1452     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, UPDATE_LIST, entries[UPDATE_NATIVE]));
1453     observerSync.Clear();
1454 
1455     status = g_nbObserverDelegate->Delete(KEY_1);
1456     EXPECT_EQ(status, OK);
1457     entries[DELETE_LOCAL].clear();
1458     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_LOCAL]));
1459     entries[DELETE_NATIVE].clear();
1460     entries[DELETE_NATIVE].push_back(entry);
1461     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, DELETE_LIST, entries[DELETE_NATIVE]));
1462     observerSync.Clear();
1463 
1464     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1465     EXPECT_EQ(status, OK);
1466 }
1467 
1468 /*
1469  * @tc.name: Pressure 012
1470  * @tc.desc: Verify that insert unusual key-value can't trigger the observer.
1471  * @tc.type: FUNC
1472  * @tc.require: SR000CCPOI
1473  * @tc.author: luqianfu
1474  */
1475 HWTEST_F(DistributeddbNbObserverTest, Pressure012, TestSize.Level1)
1476 {
1477     KvStoreObserverImpl observerLocal;
1478     KvStoreObserverImpl observerSync;
1479 
1480     DBStatus status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1481         OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1482     EXPECT_EQ(status, OK);
1483     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1484         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1485     EXPECT_EQ(status, OK);
1486 
1487     /**
1488      * @tc.steps: step1. put a unusual key = KEY_EMPTY to local and sync db and check corresponding observer.
1489      * @tc.expected: step1. both observerLocal and observerSync won't be response.
1490      */
1491     g_nbObserverDelegate->PutLocal(KEY_EMPTY, VALUE_1);
1492     vector<DistributedDB::Entry> insertLocalEntries;
1493     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
1494     vector<DistributedDB::Entry> insertNativeEntries;
1495     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
1496     observerLocal.Clear();
1497 
1498     g_nbObserverDelegate->Put(KEY_EMPTY, VALUE_1);
1499     insertLocalEntries.clear();
1500     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
1501     insertNativeEntries.clear();
1502     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
1503     observerSync.Clear();
1504 
1505     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1506     EXPECT_EQ(status, OK);
1507     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1508     EXPECT_EQ(status, OK);
1509 }
1510 
1511 /*
1512  * @tc.name: Pressure 013
1513  * @tc.desc: Verify that delete the record that do not exist can't trigger the observer.
1514  * @tc.type: FUNC
1515  * @tc.require: SR000CCPOI
1516  * @tc.author: luqianfu
1517  */
1518 HWTEST_F(DistributeddbNbObserverTest, Pressure013, TestSize.Level1)
1519 {
1520     KvStoreObserverImpl observerLocal;
1521     KvStoreObserverImpl observerSync;
1522 
1523     DBStatus status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1524         OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1525     EXPECT_EQ(status, OK);
1526     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1527         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1528     EXPECT_EQ(status, OK);
1529 
1530     /**
1531      * @tc.steps: step1. delete a record that do not exist in the local and sync db and check corresponding observer.
1532      * @tc.expected: step1. both observerLocal and observerSync won't be response.
1533      */
1534     g_nbObserverDelegate->DeleteLocal(KEY_1);
1535     vector<DistributedDB::Entry> deleteLocalEntries;
1536     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
1537     vector<DistributedDB::Entry> deleteNativeEntries;
1538     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
1539     observerLocal.Clear();
1540 
1541     g_nbObserverDelegate->Delete(KEY_1);
1542     deleteLocalEntries.clear();
1543     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
1544     deleteNativeEntries.clear();
1545     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
1546     observerSync.Clear();
1547 
1548     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1549     EXPECT_EQ(status, OK);
1550     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1551     EXPECT_EQ(status, OK);
1552 }
1553 
1554 /*
1555  * @tc.name: Pressure 014
1556  * @tc.desc: Verify that delete the record that do not exist can't trigger the observer.
1557  * @tc.type: FUNC
1558  * @tc.require: SR000CCPOI
1559  * @tc.author: luqianfu
1560  */
1561 HWTEST_F(DistributeddbNbObserverTest, Pressure014, TestSize.Level1)
1562 {
1563     KvStoreObserverImpl observerLocal;
1564     KvStoreObserverImpl observerSync;
1565     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
1566     g_nbObserverDelegate->Put(KEY_1, VALUE_1);
1567     DBStatus status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1568         OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1569     EXPECT_EQ(status, OK);
1570     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1571         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1572     EXPECT_EQ(status, OK);
1573 
1574     /**
1575      * @tc.steps: step1. put a record (KEY_1, VALUE_1) to local db and check observerLocal.
1576      * @tc.expected: step1. observerLocal will be response and observerSync won't be response.
1577      */
1578     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
1579     vector<DistributedDB::Entry> updateLocalEntries;
1580     DistributedDB::Entry entry = { KEY_1, VALUE_1 };
1581     updateLocalEntries.push_back(entry);
1582     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, UPDATE_LIST, updateLocalEntries));
1583     vector<DistributedDB::Entry> updateNativeEntries;
1584     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, updateNativeEntries));
1585     observerLocal.Clear();
1586 
1587     /**
1588      * @tc.steps: step2. put a record (KEY_1, VALUE_1) to sync db and check observerSync.
1589      * @tc.expected: step2. observerLocal won't be response and observerSync will be response.
1590      */
1591     g_nbObserverDelegate->Put(KEY_1, VALUE_1);
1592     updateLocalEntries.clear();
1593     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, updateLocalEntries));
1594     updateNativeEntries.clear();
1595     updateNativeEntries.push_back(entry);
1596     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, UPDATE_LIST, updateNativeEntries));
1597     observerSync.Clear();
1598 
1599     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1600     EXPECT_EQ(status, OK);
1601     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1602     EXPECT_EQ(status, OK);
1603     status = g_nbObserverDelegate->DeleteLocal(KEY_1);
1604     EXPECT_EQ(status, OK);
1605     status = g_nbObserverDelegate->Delete(KEY_1);
1606     EXPECT_EQ(status, OK);
1607 }
1608 
CheckPressureAfterClose(KvStoreObserverImpl & observerLocal,KvStoreObserverImpl & observerSync,vector<vector<DistributedDB::Entry>> & entries)1609 void CheckPressureAfterClose(KvStoreObserverImpl &observerLocal, KvStoreObserverImpl &observerSync,
1610     vector< vector<DistributedDB::Entry> > &entries)
1611 {
1612     /**
1613      * @tc.steps: step3. Crud on local and sync db and check corresponding observerLocal or observerSync.
1614      * @tc.expected: step3. nor observerLocal neither observerSync will be response.
1615      */
1616     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
1617     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_LOCAL]));
1618     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_NATIVE]));
1619     observerLocal.Clear();
1620 
1621     g_nbObserverDelegate->Put(KEY_1, VALUE_1);
1622     entries[INSERT_LOCAL].clear();
1623     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_LOCAL]));
1624     entries[INSERT_NATIVE].clear();
1625     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_NATIVE]));
1626     observerSync.Clear();
1627 
1628     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_2);
1629     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1630     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_NATIVE]));
1631     observerLocal.Clear();
1632 
1633     g_nbObserverDelegate->Put(KEY_1, VALUE_2);
1634     entries[UPDATE_LOCAL].clear();
1635     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1636     entries[UPDATE_NATIVE].clear();
1637     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_NATIVE]));
1638     observerSync.Clear();
1639 
1640     DBStatus status = g_nbObserverDelegate->DeleteLocal(KEY_1);
1641     EXPECT_EQ(status, OK);
1642     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_LOCAL]));
1643     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_NATIVE]));
1644     observerLocal.Clear();
1645 
1646     status = g_nbObserverDelegate->Delete(KEY_1);
1647     entries[DELETE_LOCAL].clear();
1648     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_LOCAL]));
1649     entries[DELETE_NATIVE].clear();
1650     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_NATIVE]));
1651     observerSync.Clear();
1652 
1653     g_nbObserverDelegate->DeleteLocal(KEY_1);
1654     g_nbObserverDelegate->Delete(KEY_1);
1655 }
1656 /*
1657  * @tc.name: Pressure 015
1658  * @tc.desc: Verify that close db and open it again, observer won't be triggered again.
1659  * @tc.type: FUNC
1660  * @tc.require: SR000CCPOI
1661  * @tc.author: luqianfu
1662  */
1663 HWTEST_F(DistributeddbNbObserverTest, Pressure015, TestSize.Level1)
1664 {
1665     KvStoreObserverImpl observerLocal, observerSync;
1666     DBStatus status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1667     EXPECT_EQ(status, OK);
1668     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1669         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1670     EXPECT_EQ(status, OK);
1671 
1672     /**
1673      * @tc.steps: step1. close db.
1674      * @tc.expected: step1. closed success.
1675      */
1676     EXPECT_EQ(g_nbObserverManager->CloseKvStore(g_nbObserverDelegate), OK);
1677     g_nbObserverDelegate = nullptr;
1678     delete g_nbObserverManager;
1679     g_nbObserverManager = nullptr;
1680     /**
1681      * @tc.steps: step2. open db again.
1682      * @tc.expected: step2. opened success.
1683      */
1684     Option option = g_option;
1685     if (!option.isMemoryDb) {
1686         option.createIfNecessary = IS_NOT_NEED_CREATE;
1687     }
1688     g_nbObserverDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_nbObserverManager,
1689         g_dbParameter1, option);
1690     ASSERT_TRUE(g_nbObserverManager != nullptr && g_nbObserverDelegate != nullptr);
1691 
1692     vector< vector<DistributedDB::Entry> > entries(6); // 6 element
1693     CheckPressureAfterClose(observerLocal, observerSync, entries);
1694 
1695     vector<DistributedDB::Entry> insertLocalEntries;
1696     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, insertLocalEntries));
1697     vector<DistributedDB::Entry> insertNativeEntries;
1698     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, insertNativeEntries));
1699 }
1700 
CheckPressureAfterReopen(KvStoreObserverImpl & observerLocal,KvStoreObserverImpl & observerSync,vector<vector<DistributedDB::Entry>> & entries)1701 void CheckPressureAfterReopen(KvStoreObserverImpl &observerLocal, KvStoreObserverImpl &observerSync,
1702     vector< vector<DistributedDB::Entry> > &entries)
1703 {
1704     /**
1705      * @tc.steps: step5. Crud on local and sync db and check corresponding observer.
1706      * @tc.expected: step5. It will be correctly triggered when crud  where key = KEY_1.
1707      */
1708     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_1);
1709     entries[INSERT_LOCAL].clear();
1710     DistributedDB::Entry entry = { KEY_1, VALUE_1 };
1711     entries[INSERT_LOCAL].push_back(entry);
1712     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, INSERT_LIST, entries[INSERT_LOCAL]));
1713     entries[INSERT_NATIVE].clear();
1714     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_NATIVE]));
1715     observerLocal.Clear();
1716 
1717     g_nbObserverDelegate->Put(KEY_1, VALUE_1);
1718     entries[INSERT_LOCAL].clear();
1719     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_LOCAL]));
1720     entries[INSERT_NATIVE].clear();
1721     entries[INSERT_NATIVE].push_back(entry);
1722     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, INSERT_LIST, entries[INSERT_NATIVE]));
1723     observerSync.Clear();
1724     g_nbObserverDelegate->PutLocal(KEY_1, VALUE_2);
1725     entries[UPDATE_LOCAL].clear();
1726     entry.value = VALUE_2;
1727     entries[UPDATE_LOCAL].push_back(entry);
1728     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1729     entries[UPDATE_NATIVE].clear();
1730     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_NATIVE]));
1731     observerLocal.Clear();
1732 
1733     g_nbObserverDelegate->Put(KEY_1, VALUE_2);
1734     entries[UPDATE_LOCAL].clear();
1735     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1736     entries[UPDATE_NATIVE].clear();
1737     entries[UPDATE_NATIVE].push_back(entry);
1738     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, UPDATE_LIST, entries[UPDATE_NATIVE]));
1739     observerSync.Clear();
1740 
1741     DBStatus status = g_nbObserverDelegate->DeleteLocal(KEY_1);
1742     EXPECT_EQ(status, OK);
1743     entries[DELETE_LOCAL].clear();
1744     entries[DELETE_LOCAL].push_back(entry);
1745     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ONE_TIME, DELETE_LIST, entries[DELETE_LOCAL]));
1746     entries[DELETE_NATIVE].clear();
1747     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_NATIVE]));
1748     observerLocal.Clear();
1749 }
1750 
1751 /*
1752  * @tc.name: Pressure 016
1753  * @tc.desc: Verify that close db and open it again, observer won't be triggered again,
1754  *    register observer again and it will response.
1755  * @tc.type: FUNC
1756  * @tc.require: SR000CCPOI
1757  * @tc.author: luqianfu
1758  */
1759 HWTEST_F(DistributeddbNbObserverTest, Pressure016, TestSize.Level2)
1760 {
1761     KvStoreObserverImpl observerSync, observerLocal;
1762     DBStatus status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1763         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1764     EXPECT_EQ(status, OK);
1765     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1766         OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1767     EXPECT_EQ(status, OK);
1768     /**
1769      * @tc.steps: step1. close db.
1770      * @tc.expected: step1. closed success.
1771      */
1772     EXPECT_EQ(g_nbObserverManager->CloseKvStore(g_nbObserverDelegate), OK);
1773     g_nbObserverDelegate = nullptr;
1774     delete g_nbObserverManager;
1775     g_nbObserverManager = nullptr;
1776     /**
1777      * @tc.steps: step2. open db again.
1778      * @tc.expected: step2. opened success.
1779      */
1780     if (g_option.isMemoryDb) {
1781         g_nbObserverDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_nbObserverManager,
1782             g_dbParameter1, g_option);
1783     } else {
1784         Option option = g_option;
1785         option.createIfNecessary = IS_NOT_NEED_CREATE;
1786         g_nbObserverDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_nbObserverManager,
1787             g_dbParameter1, option);
1788     }
1789     ASSERT_TRUE(g_nbObserverManager != nullptr && g_nbObserverDelegate != nullptr);
1790     vector< vector<DistributedDB::Entry> > entries(6); // 6 element
1791     CheckPressureAfterClose(observerLocal, observerSync, entries);
1792 
1793     /**
1794      * @tc.steps: step3. register observerLocal and observerSync on key = KEY_EMPTY again.
1795      * @tc.expected: step3. register success.
1796      */
1797     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1798         OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1799     EXPECT_EQ(status, OK);
1800     status = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1801         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1802     EXPECT_EQ(status, OK);
1803 
1804     CheckPressureAfterReopen(observerLocal, observerSync, entries);
1805 
1806     status = g_nbObserverDelegate->Delete(KEY_1);
1807     entries[DELETE_LOCAL].clear();
1808     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_LOCAL]));
1809     entries[DELETE_NATIVE].clear();
1810     DistributedDB::Entry entry = { KEY_1, VALUE_2 };
1811     entries[DELETE_NATIVE].push_back(entry);
1812     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ONE_TIME, DELETE_LIST, entries[DELETE_NATIVE]));
1813     observerSync.Clear();
1814 
1815     status = g_nbObserverDelegate->UnRegisterObserver(&observerLocal);
1816     EXPECT_EQ(status, OK);
1817     status = g_nbObserverDelegate->UnRegisterObserver(&observerSync);
1818     EXPECT_EQ(status, OK);
1819 }
1820 
1821 /*
1822  * @tc.name: Pressure 017
1823  * @tc.desc: Verify that close db and observer won't be triggered again,
1824  * @tc.type: FUNC
1825  * @tc.require: SR000CCPOI
1826  * @tc.author: luqianfu
1827  */
1828 HWTEST_F(DistributeddbNbObserverTest, Pressure017, TestSize.Level2)
1829 {
1830     KvStoreObserverImpl observerSync, observerLocal;
1831     DBStatus registerStatus = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1832         OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1833     EXPECT_EQ(registerStatus, OK);
1834     registerStatus = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1835         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1836     EXPECT_EQ(registerStatus, OK);
1837 
1838     /**
1839      * @tc.steps: step1. close db and check whether the observer was triggered.
1840      * @tc.expected: step1. closed success and the observer won't response.
1841      */
1842     EXPECT_EQ(g_nbObserverManager->CloseKvStore(g_nbObserverDelegate), OK);
1843     g_nbObserverDelegate = nullptr;
1844     delete g_nbObserverManager;
1845     g_nbObserverManager = nullptr;
1846 
1847     /**
1848      * @tc.steps: step2. check the local and sync observer after the data base was closed.
1849      * @tc.expected: step2. neither the local observer nor the sync observer was triggered.
1850      */
1851     vector<DistributedDB::Entry> deleteLocalEntries;
1852     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
1853     vector<DistributedDB::Entry> deleteNativeEntries;
1854     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
1855 
1856     if (g_option.isMemoryDb) {
1857         g_nbObserverDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_nbObserverManager,
1858             g_dbParameter1, g_option);
1859     } else {
1860         Option option = g_option;
1861         option.createIfNecessary = IS_NOT_NEED_CREATE;
1862         g_nbObserverDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_nbObserverManager,
1863             g_dbParameter1, option);
1864     }
1865     ASSERT_TRUE(g_nbObserverManager != nullptr && g_nbObserverDelegate != nullptr);
1866 }
1867 
1868 /*
1869  * @tc.name: Pressure 018
1870  * @tc.desc: Verify that close db and observer won't be triggered again,
1871  * @tc.type: FUNC
1872  * @tc.require: SR000CCPOI
1873  * @tc.author: luqianfu
1874  */
1875 HWTEST_F(DistributeddbNbObserverTest, Pressure018, TestSize.Level2)
1876 {
1877     KvStoreObserverImpl observerLocal;
1878     KvStoreObserverImpl observerSync;
1879     DBStatus statusLocal = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1880         OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
1881     EXPECT_EQ(statusLocal, OK);
1882     DBStatus statusSync = g_nbObserverDelegate->RegisterObserver(KEY_EMPTY,
1883         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
1884     EXPECT_EQ(statusSync, OK);
1885 
1886     /**
1887      * @tc.steps: step1. close and delete db and check whether the observer was triggered.
1888      * @tc.expected: step1. closed and deleted success and the observer won't response.
1889      */
1890     EXPECT_EQ(g_nbObserverManager->CloseKvStore(g_nbObserverDelegate), OK);
1891     g_nbObserverDelegate = nullptr;
1892     vector<DistributedDB::Entry> deleteLocalEntries;
1893     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
1894     vector<DistributedDB::Entry> deleteNativeEntries;
1895     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
1896 
1897     if (!g_option.isMemoryDb) {
1898         DBStatus status = g_nbObserverManager->DeleteKvStore(STORE_ID_1);
1899         EXPECT_TRUE(status == OK);
1900     }
1901     delete g_nbObserverManager;
1902     g_nbObserverManager = nullptr;
1903     deleteLocalEntries.clear();
1904     EXPECT_TRUE(VerifyObserverResult(observerLocal, CHANGED_ZERO_TIME, DELETE_LIST, deleteLocalEntries));
1905     deleteNativeEntries.clear();
1906     EXPECT_TRUE(VerifyObserverResult(observerSync, CHANGED_ZERO_TIME, DELETE_LIST, deleteNativeEntries));
1907 
1908     RemoveDir(DIRECTOR);
1909     g_nbObserverDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(g_nbObserverManager,
1910         g_dbParameter1, g_option);
1911     ASSERT_TRUE(g_nbObserverManager != nullptr && g_nbObserverDelegate != nullptr);
1912 }
1913 
CheckPressureAcrossDatabase(vector<KvStoreNbDelegate * > & nbDelegateVec,KvStoreObserverImpl * observerLocals,KvStoreObserverImpl * observerSyncs,vector<vector<DistributedDB::Entry>> & entries,unsigned int & opCnt)1914 void CheckPressureAcrossDatabase(vector<KvStoreNbDelegate *> &nbDelegateVec, KvStoreObserverImpl *observerLocals,
1915     KvStoreObserverImpl *observerSyncs, vector< vector<DistributedDB::Entry> > &entries, unsigned int &opCnt)
1916 {
1917     DBStatus status = nbDelegateVec[opCnt]->PutLocal(KEY_1, VALUE_1);
1918     EXPECT_EQ(status, OK);
1919     DistributedDB::Entry entry = { KEY_1, VALUE_1 };
1920     entries[INSERT_LOCAL].push_back(entry);
1921     EXPECT_TRUE(VerifyObserverResult(observerLocals[opCnt], CHANGED_ONE_TIME, INSERT_LIST, entries[INSERT_LOCAL]));
1922     EXPECT_TRUE(VerifyObserverResult(observerSyncs[opCnt], CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_NATIVE]));
1923     observerLocals[opCnt].Clear();
1924     status = nbDelegateVec[opCnt]->Put(KEY_1, VALUE_1);
1925     EXPECT_EQ(status, OK);
1926     entries[INSERT_LOCAL].clear();
1927     EXPECT_TRUE(VerifyObserverResult(observerLocals[opCnt], CHANGED_ZERO_TIME, INSERT_LIST, entries[INSERT_LOCAL]));
1928     entries[INSERT_NATIVE].clear();
1929     entries[INSERT_NATIVE].push_back(entry);
1930     EXPECT_TRUE(VerifyObserverResult(observerSyncs[opCnt], CHANGED_ONE_TIME, INSERT_LIST, entries[INSERT_NATIVE]));
1931     entries[INSERT_NATIVE].clear();
1932     observerSyncs[opCnt].Clear();
1933     status = nbDelegateVec[opCnt]->PutLocal(KEY_1, VALUE_2);
1934     EXPECT_EQ(status, OK);
1935     entry.value = VALUE_2;
1936     entries[UPDATE_LOCAL].push_back(entry);
1937     EXPECT_TRUE(VerifyObserverResult(observerLocals[opCnt], CHANGED_ONE_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1938     EXPECT_TRUE(VerifyObserverResult(observerSyncs[opCnt], CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_NATIVE]));
1939     observerLocals[opCnt].Clear();
1940     status = nbDelegateVec[opCnt]->Put(KEY_1, VALUE_2);
1941     EXPECT_EQ(status, OK);
1942     entries[UPDATE_LOCAL].clear();
1943     EXPECT_TRUE(VerifyObserverResult(observerLocals[opCnt], CHANGED_ZERO_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1944     entries[UPDATE_LOCAL].clear();
1945     entries[UPDATE_LOCAL].push_back(entry);
1946     EXPECT_TRUE(VerifyObserverResult(observerSyncs[opCnt], CHANGED_ONE_TIME, UPDATE_LIST, entries[UPDATE_LOCAL]));
1947     entries[UPDATE_LOCAL].clear();
1948     observerSyncs[opCnt].Clear();
1949     EXPECT_EQ((nbDelegateVec[opCnt]->DeleteLocal(KEY_1)), OK);
1950     entries[DELETE_LOCAL].push_back(entry);
1951     EXPECT_TRUE(VerifyObserverResult(observerLocals[opCnt], CHANGED_ONE_TIME, DELETE_LIST, entries[DELETE_LOCAL]));
1952     EXPECT_TRUE(VerifyObserverResult(observerSyncs[opCnt], CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_NATIVE]));
1953     observerLocals[opCnt].Clear();
1954     EXPECT_EQ((nbDelegateVec[opCnt]->Delete(KEY_1)), OK);
1955     entries[DELETE_LOCAL].clear();
1956     EXPECT_TRUE(VerifyObserverResult(observerLocals[opCnt], CHANGED_ZERO_TIME, DELETE_LIST, entries[DELETE_LOCAL]));
1957     entries[DELETE_NATIVE].clear();
1958     entries[DELETE_NATIVE].push_back(entry);
1959     EXPECT_TRUE(VerifyObserverResult(observerSyncs[opCnt], CHANGED_ONE_TIME, DELETE_LIST, entries[DELETE_NATIVE]));
1960     entries[DELETE_NATIVE].clear();
1961     observerSyncs[opCnt].Clear();
1962 }
1963 
1964 /*
1965  * @tc.name: Pressure 019
1966  * @tc.desc: Verify that close db and observer won't be triggered again,
1967  * @tc.type: FUNC
1968  * @tc.require: SR000CCPOI
1969  * @tc.author: luqianfu
1970  */
1971 HWTEST_F(DistributeddbNbObserverTest, Pressure019, TestSize.Level2)
1972 {
1973     KvStoreDelegateManager *nbObserverManager = nullptr;
1974     vector<string> storeIds = { STORE_ID_2, STORE_ID_3 };
1975     vector<KvStoreNbDelegate *> nbDelegateVec;
1976     DBStatus status = DistributedDBNbTestTools::GetNbDelegateStoresSuccess(nbObserverManager,
1977         nbDelegateVec, storeIds, APP_ID_2, USER_ID_2, g_option);
1978     EXPECT_EQ(status, OK);
1979     MST_LOG("nbDelegateVec.size() = %zu", nbDelegateVec.size());
1980 
1981     /**
1982      * @tc.steps: step1. register different observer on different stores.
1983      * @tc.expected: step1. each observer is registered successfully.
1984      */
1985     KvStoreObserverImpl observerLocals[STORE_NUM];
1986     KvStoreObserverImpl observerSyncs[STORE_NUM];
1987     for (unsigned int opCnt = 0; opCnt < static_cast<unsigned int>(nbDelegateVec.size()); ++opCnt) {
1988         MST_LOG("opCnt = %d", opCnt);
1989         status = nbDelegateVec[opCnt]->RegisterObserver(KEY_EMPTY, OBSERVER_CHANGES_LOCAL_ONLY, &observerLocals[opCnt]);
1990         EXPECT_EQ(status, OK);
1991         status = nbDelegateVec[opCnt]->RegisterObserver(KEY_EMPTY,
1992             OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSyncs[opCnt]);
1993         EXPECT_EQ(status, OK);
1994     }
1995 
1996     /**
1997      * @tc.steps: step2. crud on each db of corresponding observer on different stores.
1998      * @tc.expected: step2. each observer is triggered successfully.
1999      */
2000     vector< vector<DistributedDB::Entry> > entries(6); // 6 element
2001     for (unsigned int opCnt = 0; opCnt < static_cast<unsigned int>(nbDelegateVec.size()); ++opCnt) {
2002         CheckPressureAcrossDatabase(nbDelegateVec, observerLocals, observerSyncs, entries, opCnt);
2003     }
2004     for (unsigned int opCnt = 0; opCnt < static_cast<unsigned int>(nbDelegateVec.size()); ++opCnt) {
2005         status = nbDelegateVec[opCnt]->UnRegisterObserver(&observerLocals[opCnt]);
2006         EXPECT_EQ(status, OK);
2007         status = nbDelegateVec[opCnt]->UnRegisterObserver(&observerSyncs[opCnt]);
2008         EXPECT_EQ(status, OK);
2009     }
2010 
2011     unsigned int delegateVecSize = static_cast<unsigned int>(nbDelegateVec.size());
2012     for (unsigned int opCnt = 0; opCnt < delegateVecSize; ++opCnt) {
2013         EXPECT_EQ(nbObserverManager->CloseKvStore(nbDelegateVec[opCnt]), OK);
2014         nbDelegateVec[opCnt] = nullptr;
2015     }
2016     delete nbObserverManager;
2017     nbObserverManager = nullptr;
2018 }
2019 
CheckPressureLongCompare(vector<Entry> & entriesBatch,ConcurParam * threadParam,Entry & entryCurrent)2020 void CheckPressureLongCompare(vector<Entry> &entriesBatch, ConcurParam *threadParam, Entry &entryCurrent)
2021 {
2022     bool isExist = false;
2023     if (threadParam->tag_ == ReadOrWriteTag::WRITE) {
2024         for (auto &entry : entriesBatch) {
2025             if (CompareVector(entry.key, entryCurrent.key)) {
2026                 isExist = true;
2027             }
2028         }
2029         if (!isExist) {
2030             entriesBatch.push_back(entryCurrent);
2031         }
2032     } else if (threadParam->tag_ == ReadOrWriteTag::DELETE) {
2033         for (unsigned int index = 0; index < static_cast<unsigned int>(entriesBatch.size()); ++index) {
2034             if (CompareVector(entriesBatch[index].key, entryCurrent.key)) {
2035                 entriesBatch.erase(entriesBatch.begin() + index);
2036             }
2037         }
2038     }
2039 }
2040 
CheckPressureLongConcurrency(vector<Entry> & entriesBatch)2041 void CheckPressureLongConcurrency(vector<Entry> &entriesBatch)
2042 {
2043     std::random_device randDevAnyKeyNo, randDevTag;
2044     std::mt19937 genRandAnyKeyNo(randDevAnyKeyNo()), genRandTag(randDevTag());
2045     std::uniform_int_distribution<unsigned int> disRandAnyKeyNo(ANY_RECORDS_NUM_START, ANY_RECORDS_NUM_END);
2046     std::uniform_int_distribution<int> disRandTag(static_cast<int>(ReadOrWriteTag::READ),
2047         static_cast<int>(ReadOrWriteTag::REGISTER));
2048     unsigned int randKeyNo;
2049     unsigned int threadCurId = 0;
2050     int randFlag;
2051 
2052     std::chrono::time_point<chrono::steady_clock, chrono::microseconds> start, end;
2053     std::chrono::duration<uint64_t, std::micro> dur;
2054     double operInterval = 0.0;
2055 
2056     start = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
2057     while (operInterval < static_cast<double>(LONG_TIME_TEST_SECONDS)) {
2058         auto threadParam = new (std::nothrow) ConcurParam;
2059         ASSERT_NE(threadParam, nullptr);
2060         threadParam->entryPtr_ = new (std::nothrow) DistributedDB::Entry;
2061         ASSERT_NE(threadParam->entryPtr_, nullptr);
2062         threadParam->threadId_ = threadCurId++;
2063         randFlag = disRandTag(genRandTag);
2064         threadParam->tag_ = static_cast<ReadOrWriteTag>(randFlag);
2065         randKeyNo = disRandAnyKeyNo(genRandAnyKeyNo);
2066 
2067         Entry entryCurrent;
2068         GenerateRecord(randKeyNo, entryCurrent);
2069 
2070         CheckPressureLongCompare(entriesBatch, threadParam, entryCurrent);
2071 
2072         threadParam->entryPtr_->key = entryCurrent.key;
2073         threadParam->entryPtr_->value = entryCurrent.value;
2074         std::thread thread = std::thread(ConcurOperThread, reinterpret_cast<ConcurParam *>(threadParam));
2075         thread.join();
2076 
2077         std::this_thread::sleep_for(std::chrono::duration<float, std::milli>(LONG_TIME_INTERVAL_MILLSECONDS));
2078         end = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::steady_clock::now());
2079         dur = std::chrono::duration_cast<chrono::microseconds>(end - start);
2080         operInterval = static_cast<double>(dur.count()) * chrono::microseconds::period::num
2081             / chrono::microseconds::period::den;
2082         delete threadParam->entryPtr_;
2083         threadParam->entryPtr_ = nullptr;
2084         delete threadParam;
2085         threadParam = nullptr;
2086     }
2087 }
2088 
2089 /*
2090  * @tc.name: Pressure 021
2091  * @tc.desc: Verify that can read and write Concurrency observer, and each observer will success
2092  * @tc.type: LONGTIME TEST
2093  * @tc.require: SR000CCPOI
2094  * @tc.author: luqianfu
2095  */
2096 HWTEST_F(DistributeddbNbObserverTest, Pressure021, TestSize.Level3)
2097 {
2098     vector<Entry> entriesBatch;
2099     vector<Key> allKeys;
2100     GenerateRecords(BATCH_RECORDS, DEFAULT_START, allKeys, entriesBatch);
2101 
2102     DBStatus status = DistributedDBNbTestTools::PutBatch(*g_nbObserverDelegate, entriesBatch);
2103     EXPECT_TRUE(status == DBStatus::OK);
2104     vector<Entry> valueResult;
2105     status = DistributedDBNbTestTools::GetEntries(*g_nbObserverDelegate, KEY_SEARCH_4, valueResult);
2106     EXPECT_EQ(status, OK);
2107     MST_LOG("value size %zu", valueResult.size());
2108 
2109     /**
2110      * @tc.steps: step1. start 6 threads to register 6 observers to crud on db and
2111      *    start 4 threads to register observer at the same time.
2112      * @tc.expected: step1. each thread start successfully and each observer register successfully
2113      *    and could not effect each other.
2114      */
2115     CheckPressureLongConcurrency(entriesBatch);
2116 
2117     while (entriesBatch.size() > 0) {
2118         status = DistributedDBNbTestTools::Delete(*g_nbObserverDelegate, entriesBatch[0].key);
2119         EXPECT_EQ(status, OK);
2120         entriesBatch.erase(entriesBatch.begin());
2121     }
2122     MST_LOG("entriesBatch.size() = %zu", entriesBatch.size());
2123 }
2124 
2125 /*
2126  * @tc.name: RekeyNbDb 001
2127  * @tc.desc: verify that Rekey will return busy when there are registered observer or putting data to db.
2128  * @tc.type: FUNC
2129  * @tc.require: SR000CQDT4
2130  * @tc.author: fengxiaoyun
2131  */
2132 HWTEST_F(DistributeddbNbObserverTest, RekeyNbDb001, TestSize.Level2)
2133 {
2134     KvStoreNbDelegate *nbObserverDelegate = nullptr;
2135     KvStoreDelegateManager *manager = nullptr;
2136     Option option;
2137 
2138     nbObserverDelegate = DistributedDBNbTestTools::GetNbDelegateSuccess(manager, g_dbParameter2, option);
2139     ASSERT_TRUE(manager != nullptr && nbObserverDelegate != nullptr);
2140 
2141     /**
2142      * @tc.steps: step1. register observer.
2143      * @tc.expected: step1. register successfully.
2144      */
2145     KvStoreObserverImpl observerLocal;
2146     KvStoreObserverImpl observerSync;
2147     DBStatus status = nbObserverDelegate->RegisterObserver(KEY_EMPTY,
2148         OBSERVER_CHANGES_LOCAL_ONLY, &observerLocal);
2149     EXPECT_EQ(status, OK);
2150     status = nbObserverDelegate->RegisterObserver(KEY_EMPTY,
2151         OBSERVER_CHANGES_NATIVE | OBSERVER_CHANGES_FOREIGN, &observerSync);
2152     EXPECT_EQ(status, OK);
2153 
2154     /**
2155      * @tc.steps: step2. call Rekey to update passwd to passwd_1.
2156      * @tc.expected: step2. Rekey returns BUSY.
2157      */
2158     EXPECT_TRUE(nbObserverDelegate->Rekey(g_passwd1) == BUSY);
2159 
2160     /**
2161      * @tc.steps: step3. unregister observer.
2162      * @tc.expected: step3. unregister successfully.
2163      */
2164     status = nbObserverDelegate->UnRegisterObserver(&observerLocal);
2165     EXPECT_EQ(status, OK);
2166     status = nbObserverDelegate->UnRegisterObserver(&observerSync);
2167     EXPECT_EQ(status, OK);
2168 
2169     /**
2170      * @tc.steps: step4. put (1k,4M) of (k,v) to db.
2171      * @tc.expected: step4. put successfully.
2172      */
2173     std::mutex count;
2174     vector<Entry> entriesBatch;
2175     vector<Key> allKeys;
2176     GenerateFixedRecords(entriesBatch, allKeys, RECORDS_NUM_START, ONE_K_LONG_STRING, FOUR_M_LONG_STRING);
__anon6e5eea800102() 2177     thread subThread([&nbObserverDelegate, &entriesBatch]() {
2178         DBStatus putStatus = nbObserverDelegate->Put(entriesBatch[0].key, entriesBatch[0].value);
2179         EXPECT_TRUE(putStatus == OK || putStatus == BUSY);
2180     });
2181     subThread.detach();
2182 
2183     /**
2184      * @tc.steps: step5. call Rekey to update passwd to passwd_2 when put data to db.
2185      * @tc.expected: step5. Rekey returns BUSY.
2186      */
2187     status = nbObserverDelegate->Rekey(g_passwd2);
2188     EXPECT_TRUE(status == OK || status == BUSY);
2189     std::this_thread::sleep_for(std::chrono::seconds(FIVE_SECONDS));
2190     EXPECT_TRUE(manager->CloseKvStore(nbObserverDelegate) == OK);
2191     nbObserverDelegate = nullptr;
2192     EXPECT_TRUE(manager->DeleteKvStore(STORE_ID_2) == OK);
2193     delete manager;
2194     manager = nullptr;
2195 }
2196 
2197 /*
2198  * @tc.name: RekeyNbDb 002
2199  * @tc.desc: verify that Rekey will return busy when there are opened conflict notifier.
2200  * @tc.type: FUNC
2201  * @tc.require: SR000CQDT4
2202  * @tc.author: fengxiaoyun
2203  */
2204 HWTEST_F(DistributeddbNbObserverTest, RekeyNbDb002, TestSize.Level1)
2205 {
2206     /**
2207      * @tc.steps: step1. register conflict notifier.
2208      * @tc.expected: step1. register successfully.
2209      */
2210     ConflictNbCallback callback;
2211     std::vector<ConflictData> conflictData;
2212     auto notifier = bind(&ConflictNbCallback::NotifyCallBack, &callback, placeholders::_1, &conflictData);
2213     DBStatus status = g_nbObserverDelegate->SetConflictNotifier(CONFLICT_FOREIGN_KEY_ONLY, notifier);
2214     EXPECT_TRUE(status == OK);
2215 
2216     /**
2217      * @tc.steps: step2. call Rekey to update passwd to passwd_1.
2218      * @tc.expected: step2. Rekey returns BUSY.
2219      */
2220     EXPECT_TRUE(g_nbObserverDelegate->Rekey(g_passwd1) == BUSY);
2221 }
2222 }