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 <functional>
16 #include <gtest/gtest.h>
17 #include <memory>
18 
19 #include "uri.h"
20 #define private public
21 #include "data_ability_observer_proxy.h"
22 #include "dataobs_mgr_inner_ext.h"
23 #include "dataobs_mgr_errors.h"
24 #include "mock.h"
25 
26 using namespace OHOS;
27 using namespace testing::ext;
28 using namespace testing;
29 
30 using Uri = OHOS::Uri;
31 
32 namespace OHOS {
33 namespace DataObsMgrInnerExtTest {
34 using namespace AAFwk;
35 class DataObsMgrInnerExtTest : public testing::Test {
36 public:
37     static void SetUpTestCase(void);
38     static void TearDownTestCase(void);
39     void SetUp();
40     void TearDown();
41 
42     void RegisterObserverUtil(std::shared_ptr<DataObsMgrInnerExt> &dataObsMgrInnerExt, Uri &uri,
43         const sptr<IDataAbilityObserver> &callback, uint32_t times, bool isFuzzy);
44 
45     bool UrisEqual(std::list<Uri> uri1, std::list<Uri> uri2);
46 
47     bool ChangeInfoEqual(const ChangeInfo &changeInfo1, const ChangeInfo &changeInfo2);
48 };
49 
SetUpTestCase(void)50 void DataObsMgrInnerExtTest::SetUpTestCase(void) {}
TearDownTestCase(void)51 void DataObsMgrInnerExtTest::TearDownTestCase(void) {}
SetUp()52 void DataObsMgrInnerExtTest::SetUp() {}
TearDown()53 void DataObsMgrInnerExtTest::TearDown() {}
54 
RegisterObserverUtil(std::shared_ptr<DataObsMgrInnerExt> & dataObsMgrInnerExt,Uri & uri,const sptr<IDataAbilityObserver> & callback,uint32_t times,bool isFuzzy)55 void DataObsMgrInnerExtTest::RegisterObserverUtil(std::shared_ptr<DataObsMgrInnerExt> &dataObsMgrInnerExt, Uri &uri,
56     const sptr<IDataAbilityObserver> &callback, uint32_t times, bool isFuzzy)
57 {
58     while (times-- > 0) {
59         EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, callback, isFuzzy), SUCCESS);
60     }
61 }
62 
UrisEqual(std::list<Uri> uri1,std::list<Uri> uri2)63 bool DataObsMgrInnerExtTest::UrisEqual(std::list<Uri> uri1, std::list<Uri> uri2)
64 {
65     if (uri1.size() != uri2.size()) {
66         return false;
67     }
68     auto cmp = [](const Uri &first, const Uri &second) {
69         return first.ToString() < second.ToString();
70     };
71     uri1.sort(cmp);
72     uri2.sort(cmp);
73     auto it1 = uri1.begin();
74     auto it2 = uri2.begin();
75     for (; it1 != uri1.end() && it2 != uri2.end(); it1++, it2++) {
76         if (!it1->Equals(*it2)) {
77             return false;
78         }
79     }
80     return true;
81 }
82 
ChangeInfoEqual(const ChangeInfo & changeInfo1,const ChangeInfo & changeInfo2)83 bool DataObsMgrInnerExtTest::ChangeInfoEqual(const ChangeInfo &changeInfo1, const ChangeInfo &changeInfo2)
84 {
85     if (changeInfo1.changeType_ != changeInfo2.changeType_) {
86         return false;
87     }
88 
89     if (!UrisEqual(changeInfo1.uris_, changeInfo2.uris_)) {
90         return false;
91     }
92 
93     if (changeInfo1.size_ != changeInfo2.size_) {
94         return false;
95     }
96 
97     return strncmp(reinterpret_cast<const char *>(changeInfo1.data_), reinterpret_cast<const char *>(changeInfo2.data_),
98         changeInfo2.size_) == 0;
99 }
100 
101 /*
102  * Feature: DataObsMgrInnerExt
103  * Function: HandleRegisterObserver test
104  * SubFunction: 0100
105  * FunctionPoints: NA
106  * EnvConditions: NA
107  * CaseDescription:Register one non-fuzzy observer one times
108  */
109 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0100, TestSize.Level1)
110 {
111     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
112     std::string uriBase = "datashare://Authority/com.domainname.dataability.persondata";
113     Uri uri1(uriBase + "/Person");
114     Uri uri2(uriBase + "/Person/2");
115     sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
116 
117     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer), SUCCESS);
118 
119     ChangeInfo changeInfo = { ChangeInfo::ChangeType::OTHER, {uri1} };
120     dataObsMgrInnerExt->HandleNotifyChange(changeInfo);
121     EXPECT_TRUE(ChangeInfoEqual(observer->changeInfo_, changeInfo));
122 
123     changeInfo.uris_ = {uri1};
124     observer->ReSet();
125     dataObsMgrInnerExt->HandleNotifyChange(changeInfo);
126     EXPECT_TRUE(ChangeInfoEqual(observer->changeInfo_, changeInfo));
127 
128     changeInfo.uris_ = {uri2};
129     observer->ReSet();
130     dataObsMgrInnerExt->HandleNotifyChange(changeInfo);
131     EXPECT_TRUE(ChangeInfoEqual(observer->changeInfo_, {}));
132 }
133 
134 /*
135  * Feature: DataObsMgrInnerExt
136  * Function: HandleRegisterObserver test
137  * SubFunction: 0200
138  * FunctionPoints: NA
139  * EnvConditions: NA
140  * CaseDescription:Register one non-fuzzy observer mutiple times
141  */
142 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0200, TestSize.Level1)
143 {
144     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
145     std::string uriBase = "datashare://Authority/com.domainname.dataability.persondata";
146     Uri uri1(uriBase + "/Person");
147     Uri uri2(uriBase + "/Person/2");
148     Uri uri3(uriBase + "/Person/3");
149     sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
150 
151     RegisterObserverUtil(dataObsMgrInnerExt, uri1, observer, 1, false);
152     RegisterObserverUtil(dataObsMgrInnerExt, uri2, observer, DataObsMgrInnerExt::OBS_NUM_MAX - 1, false);
153     RegisterObserverUtil(dataObsMgrInnerExt, uri3, observer, DataObsMgrInnerExt::OBS_NUM_MAX, false);
154 
155     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } });
156     EXPECT_TRUE(UrisEqual(observer->changeInfo_.uris_, { uri1 }));
157 
158     observer->ReSet();
159     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri2 } });
160     EXPECT_EQ(observer->onChangeCall_, DataObsMgrInnerExt::OBS_NUM_MAX - 1);
161 
162     observer->ReSet();
163     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri3 } });
164     EXPECT_EQ(observer->onChangeCall_, DataObsMgrInnerExt::OBS_NUM_MAX);
165 }
166 
167 /*
168 * Feature: DataObsMgrInnerExt
169 * Function: HandleRegisterObserver test
170 * SubFunction: 0300
171 * FunctionPoints: NA
172 * EnvConditions: NA
173 * CaseDescription:Register mutiple non-fuzzy observer mutiple times
174 */
175 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0300, TestSize.Level1)
176 {
177     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
178     std::string uriBase = "datashare://Authority/com.domainname.dataability.persondata";
179     Uri uri1(uriBase + "/Person");
180     Uri uri2(uriBase + "/Person/2");
181     Uri uri3(uriBase + "/Person/3");
182 
183     sptr<MockDataAbilityObserverStub> observer1(new (std::nothrow) MockDataAbilityObserverStub());
184     sptr<MockDataAbilityObserverStub> observer2(new (std::nothrow) MockDataAbilityObserverStub());
185     sptr<MockDataAbilityObserverStub> observer3(new (std::nothrow) MockDataAbilityObserverStub());
186 
187     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1), SUCCESS);
188     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer2), SUCCESS);
189 
190     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer2), SUCCESS);
191     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer3), SUCCESS);
192 
193     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri3, observer3), SUCCESS);
194     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri3, observer1), SUCCESS);
195 
196     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } });
197     EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri1 }));
198     EXPECT_TRUE(UrisEqual(observer2->changeInfo_.uris_, { uri1 }));
199     EXPECT_TRUE(UrisEqual(observer3->changeInfo_.uris_, {}));
200 
201     observer1->ReSet();
202     observer2->ReSet();
203     observer3->ReSet();
204     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri2, uri3 } });
205     EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri3 }));
206     EXPECT_TRUE(UrisEqual(observer2->changeInfo_.uris_, { uri2 }));
207     EXPECT_TRUE(UrisEqual(observer3->changeInfo_.uris_, { uri2, uri3 }));
208 }
209 
210 /*
211  * Feature: DataObsMgrInnerExt
212  * Function: HandleRegisterObserver test
213  * SubFunction: 0400
214  * FunctionPoints: NA
215  * EnvConditions: NA
216  * CaseDescription:Register one fuzzy observer one times
217  *          Person1 <-obs
218  *           2   4
219  *          3
220  */
221 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0400, TestSize.Level1)
222 {
223     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
224     std::string uriBase = "datashare://Authority/com.domainname.dataability.persondata";
225 
226     Uri uri1(uriBase + "/Person1");
227     Uri uri12(uriBase + "/Person1/2");
228     Uri uri123(uriBase + "/Person1/2/3");
229     Uri uri14(uriBase + "/Person1/4");
230     Uri uri2(uriBase + "/Person2");
231 
232     sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
233     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, true), SUCCESS);
234 
235     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } });
236     EXPECT_TRUE(UrisEqual(observer->changeInfo_.uris_, { uri1 }));
237 
238     observer->ReSet();
239     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri12, uri123, uri14, uri2 } });
240     EXPECT_TRUE(UrisEqual(observer->changeInfo_.uris_, { uri12, uri123, uri14 }));
241 }
242 
243 /*
244  * Feature: DataObsMgrInnerExt
245  * Function: HandleRegisterObserver test
246  * SubFunction: 0500
247  * FunctionPoints: NA
248  * EnvConditions: NA
249  * CaseDescription:Register one fuzzy observer mutiple times
250  *          Person1 <-obs
251  *           2   4 <-2*obs
252  *          3     5
253  */
254 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0500, TestSize.Level1)
255 {
256     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
257     std::string uriBase = "datashare://Authority/com.domainname.dataability.persondata";
258 
259     Uri uri1(uriBase + "/Person1");
260     Uri uri12(uriBase + "/Person1/2");
261     Uri uri123(uriBase + "/Person1/2/3");
262     Uri uri14(uriBase + "/Person1/4");
263     Uri uri145(uriBase + "/Person1/4/5");
264 
265     sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
266 
267     RegisterObserverUtil(dataObsMgrInnerExt, uri1, observer, 1, true);
268     RegisterObserverUtil(dataObsMgrInnerExt, uri14, observer, 2, true);
269 
270     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } });
271     EXPECT_TRUE(UrisEqual(observer->changeInfo_.uris_, { uri1 }));
272 
273     observer->ReSet();
274     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri14, uri145, uri12, uri123 } });
275     EXPECT_TRUE(UrisEqual(observer->changeInfo_.uris_, { uri14, uri14, uri14, uri145, uri145, uri145, uri12, uri123 }));
276 }
277 
278 /*
279  * Feature: DataObsMgrInnerExt
280  * Function: HandleRegisterObserver test
281  * SubFunction: 0600
282  * FunctionPoints: NA
283  * EnvConditions: NA
284  * CaseDescription:Register mutiple fuzzy observer mutiple times
285  *          Person1 <-obs1
286  *           2   4 <-obs2
287  *    obs1->3     5
288  */
289 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0600, TestSize.Level1)
290 {
291     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
292     std::string uriBase = "datashare://Authority/com.domainname.dataability.persondata";
293 
294     Uri uri1(uriBase + "/Person1");
295     Uri uri12(uriBase + "/Person1/2");
296     Uri uri123(uriBase + "/Person1/2/3");
297     Uri uri14(uriBase + "/Person1/4");
298     Uri uri145(uriBase + "/Person1/4/5");
299 
300     sptr<MockDataAbilityObserverStub> observer1(new (std::nothrow) MockDataAbilityObserverStub());
301     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, true), SUCCESS);
302     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri123, observer1, true), SUCCESS);
303 
304     sptr<MockDataAbilityObserverStub> observer2(new (std::nothrow) MockDataAbilityObserverStub());
305     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri14, observer2, true), SUCCESS);
306 
307     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } });
308     EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri1 }));
309     EXPECT_TRUE(UrisEqual(observer2->changeInfo_.uris_, {}));
310 
311     observer1->ReSet();
312     observer2->ReSet();
313     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri14, uri145, uri12, uri123 } });
314     EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri14, uri145, uri12, uri123, uri123 }));
315     EXPECT_TRUE(UrisEqual(observer2->changeInfo_.uris_, { uri14, uri145 }));
316 }
317 
318 /*
319  * Feature: DataObsMgrInnerExt
320  * Function: HandleRegisterObserver test
321  * SubFunction: 0700
322  * FunctionPoints: NA
323  * EnvConditions: NA
324  * CaseDescription:Register mix observer mutiple times
325  *          Person1 <-obs1(fuzzy)
326  *         2   4 <-obs2(fuzzy and nofuzzy)
327  *        3     5
328  */
329 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0700, TestSize.Level1)
330 {
331     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
332     std::string uriBase = "datashare://Authority/com.domainname.dataability.persondata";
333 
334     Uri uri1(uriBase + "/Person1");
335     Uri uri12(uriBase + "/Person1/2");
336     Uri uri123(uriBase + "/Person1/2/3");
337     Uri uri14(uriBase + "/Person1/4");
338     Uri uri145(uriBase + "/Person1/4/5");
339 
340     sptr<MockDataAbilityObserverStub> observer1(new (std::nothrow) MockDataAbilityObserverStub());
341     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, true), SUCCESS);
342 
343     sptr<MockDataAbilityObserverStub> observer2(new (std::nothrow) MockDataAbilityObserverStub());
344     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri14, observer2, true), SUCCESS);
345     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri14, observer2, false), SUCCESS);
346 
347     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } });
348     EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri1 }));
349     EXPECT_TRUE(UrisEqual(observer2->changeInfo_.uris_, {}));
350 
351     observer1->ReSet();
352     observer2->ReSet();
353     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri14, uri145, uri12, uri123 } });
354     EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri14, uri145, uri12, uri123 }));
355     EXPECT_TRUE(UrisEqual(observer2->changeInfo_.uris_, { uri14, uri14, uri145 }));
356 }
357 
358 /*
359  * Feature: DataObsMgrInnerExt
360  * Function: HandleUnregisterObserver test
361  * SubFunction: 0100
362  * FunctionPoints: NA
363  * EnvConditions: NA
364  * CaseDescription:UnRegister observer
365  */
366 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleUnregisterObserver_0100, TestSize.Level1)
367 {
368     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
369     std::string uriBase1 = "datashare://Authority1/com.domainname.dataability.persondata";
370     std::string uriBase2 = "datashare://Authority2/com.domainname.dataability.persondata";
371 
372     Uri uri1(uriBase1 + "/Person1");
373     Uri uri12(uriBase1 + "/Person1/2");
374     Uri uri2(uriBase2 + "/Person2");
375 
376     sptr<MockDataAbilityObserverStub> observer1(new (std::nothrow) MockDataAbilityObserverStub());
377     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, true), SUCCESS);
378     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } });
379     EXPECT_TRUE(UrisEqual(observer1->changeInfo_.uris_, { uri1 }));
380     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 1);
381     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri1, observer1), SUCCESS);
382     observer1->ReSet();
383     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } });
384     EXPECT_EQ(observer1->onChangeCall_, 0);
385 }
386 
387 /*
388  * Feature: DataObsMgrInnerExt
389  * Function: HandleUnregisterObserver test
390  * SubFunction: 0200
391  * FunctionPoints: NA
392  * EnvConditions: NA
393  * CaseDescription:UnRegister one observers mutiple times
394  */
395 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleUnregisterObserver_0200, TestSize.Level1)
396 {
397     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
398     std::string uriBase = "datashare://Authority1/com.domainname.dataability.persondata";
399 
400     Uri uri1(uriBase + "/Person1");
401 
402     sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
403     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 0);
404 
405     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, true), SUCCESS);
406     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 1);
407     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.find(observer)->second->ref, 2);
408 
409     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer, false), SUCCESS);
410     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 1);
411     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.find(observer)->second->ref, 3);
412 
413     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } });
414     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri1, observer), SUCCESS);
415     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 0);
416     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri1, observer), SUCCESS);
417     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 0);
418     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1 } });
419     EXPECT_EQ(observer->onChangeCall_, 2);
420 }
421 
422 /*
423  * Feature: DataObsMgrInnerExt
424  * Function: HandleUnregisterObserver test
425  * SubFunction: 0300
426  * FunctionPoints: NA
427  * EnvConditions: NA
428  * CaseDescription:UnRegister mutiple observers on mutiple uri
429  *          Person1
430  *           2   3<-2*obs1、obs2
431  *        obs1->4 5<-obs2
432  */
433 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleUnregisterObserver_0300, TestSize.Level1)
434 {
435     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
436     std::string uriBase = "datashare://Authority1/com.domainname.dataability.persondata";
437 
438     Uri uri1(uriBase + "/Person1");
439     Uri uri12(uriBase + "/Person1/2");
440     Uri uri13(uriBase + "/Person1/3");
441     Uri uri134(uriBase + "/Person1/3/4");
442     Uri uri135(uriBase + "/Person1/3/5");
443 
444     sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
445     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri13, observer, true), SUCCESS);
446     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri13, observer, false), SUCCESS);
447     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri134, observer, false), SUCCESS);
448 
449     sptr<MockDataAbilityObserverStub> observer2(new (std::nothrow) MockDataAbilityObserverStub());
450     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri13, observer2, true), SUCCESS);
451     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri135, observer2, true), SUCCESS);
452     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 2);
453     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.find(observer2)->second->ref, 3);
454 
455     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri135, observer), SUCCESS);
456     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri135, observer2), SUCCESS);
457     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 2);
458     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.find(observer2)->second->ref, 2);
459 
460     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri135 } });
461     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri13, observer2), SUCCESS);
462     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri135 } });
463     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 1);
464 
465     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri13, observer), SUCCESS);
466     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 1);
467     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri13 } });
468 
469     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri134, observer), SUCCESS);
470     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 0);
471     EXPECT_TRUE(dataObsMgrInnerExt->root_->childrens_.empty());
472     EXPECT_EQ(observer->onChangeCall_, 2);
473     EXPECT_EQ(observer2->onChangeCall_, 1);
474 }
475 
476 /*
477  * Feature: DataObsMgrInnerExt
478  * Function: Register and UnRegister test
479  * SubFunction: 0100
480  * FunctionPoints: NA
481  * EnvConditions: NA
482  * CaseDescription:Register and UnRegister when observers over limmit
483  */
484 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_RegisterAndUnRegister_0100, TestSize.Level1)
485 {
486     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
487     std::string uriBase = "datashare://Authority1/com.domainname.dataability.persondata";
488     Uri uri1(uriBase + "/Person1");
489     Uri uri2(uriBase + "/Person2");
490 
491     sptr<MockDataAbilityObserverStub> observer1(new (std::nothrow) MockDataAbilityObserverStub());
492     sptr<MockDataAbilityObserverStub> observer2(new (std::nothrow) MockDataAbilityObserverStub());
493 
494     RegisterObserverUtil(dataObsMgrInnerExt, uri1, observer1, 50, false);
495     auto obsRecipientRef1 = dataObsMgrInnerExt->obsRecipientRefs.find(observer1);
496     EXPECT_TRUE(obsRecipientRef1 != dataObsMgrInnerExt->obsRecipientRefs.end() && obsRecipientRef1->second->ref == 51);
497     EXPECT_TRUE(dataObsMgrInnerExt->obsRecipientRefs.find(observer2) == dataObsMgrInnerExt->obsRecipientRefs.end());
498     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer1, false), DATAOBS_SERVICE_OBS_LIMMIT);
499     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri1, observer2, true), DATAOBS_SERVICE_OBS_LIMMIT);
500     EXPECT_EQ(obsRecipientRef1->second->ref, 51);
501     EXPECT_TRUE(dataObsMgrInnerExt->obsRecipientRefs.find(observer2) == dataObsMgrInnerExt->obsRecipientRefs.end());
502 
503     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri2 } });
504     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri1, observer1), SUCCESS);
505     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri2 } });
506     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri2, observer1), SUCCESS);
507     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri2 } });
508     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri2, observer2), SUCCESS);
509     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri2 } });
510     EXPECT_TRUE(dataObsMgrInnerExt->obsRecipientRefs.find(observer1) == dataObsMgrInnerExt->obsRecipientRefs.end());
511     EXPECT_TRUE(dataObsMgrInnerExt->obsRecipientRefs.find(observer2) == dataObsMgrInnerExt->obsRecipientRefs.end());
512     EXPECT_EQ(observer1->onChangeCall_, 50);
513     EXPECT_EQ(observer2->onChangeCall_, 0);
514 }
515 
516 /*
517  * Feature: DataObsMgrInnerExt
518  * Function: Register and UnRegister test
519  * SubFunction: 0200
520  * FunctionPoints: NA
521  * EnvConditions: NA
522  * CaseDescription:Register and UnRegister when observers over limmit
523  */
524 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_RegisterAndUnRegister_0200, TestSize.Level1)
525 {
526     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
527     std::string uriBase = "datashare://Authority1/com.domainname.dataability.persondata";
528     Uri uri1(uriBase + "/Person1");
529     Uri uri2(uriBase + "/Person2");
530 
531     sptr<MockDataAbilityObserverStub> observer1(new (std::nothrow) MockDataAbilityObserverStub());
532     sptr<MockDataAbilityObserverStub> observer2(new (std::nothrow) MockDataAbilityObserverStub());
533 
534     RegisterObserverUtil(dataObsMgrInnerExt, uri2, observer1, 20, true);
535     RegisterObserverUtil(dataObsMgrInnerExt, uri2, observer2, 30, false);
536     auto obsRecipientRef1 = dataObsMgrInnerExt->obsRecipientRefs.find(observer1);
537     auto obsRecipientRef2 = dataObsMgrInnerExt->obsRecipientRefs.find(observer2);
538     EXPECT_TRUE(obsRecipientRef1 != dataObsMgrInnerExt->obsRecipientRefs.end() && obsRecipientRef1->second->ref == 21);
539     EXPECT_TRUE(obsRecipientRef2 != dataObsMgrInnerExt->obsRecipientRefs.end() && obsRecipientRef2->second->ref == 31);
540     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer1, false), DATAOBS_SERVICE_OBS_LIMMIT);
541     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri2, observer2, false), DATAOBS_SERVICE_OBS_LIMMIT);
542     EXPECT_EQ(obsRecipientRef1->second->ref, 21);
543     EXPECT_EQ(obsRecipientRef2->second->ref, 31);
544 
545     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri2 } });
546     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri1, observer1), SUCCESS);
547     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri2 } });
548     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri2, observer1), SUCCESS);
549     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri2 } });
550     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(uri2, observer2), SUCCESS);
551     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri2 } });
552     EXPECT_TRUE(dataObsMgrInnerExt->obsRecipientRefs.find(observer1) == dataObsMgrInnerExt->obsRecipientRefs.end());
553     EXPECT_TRUE(dataObsMgrInnerExt->obsRecipientRefs.find(observer2) == dataObsMgrInnerExt->obsRecipientRefs.end());
554     EXPECT_EQ(observer1->onChangeCall_, 40);
555     EXPECT_EQ(observer2->onChangeCall_, 90);
556 }
557 
558 /*
559  * Feature: DataObsMgrInnerExt
560  * Function: HandleUnregisterObserver no uri
561  * SubFunction: 0100
562  * FunctionPoints: NA
563  * EnvConditions: NA
564  * CaseDescription:HandleUnregisterObserver one observers on all uri
565  *          Person1<-5*obs1(fuzzy)+25*obs2
566  *   10、20->2   3<-15*obs1+15*obs2
567  *     20*obs1->4 5<-25*obs1+5*obs2
568  */
569 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleUnregisterObserverAll_0100, TestSize.Level1)
570 {
571     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
572     std::string uriBase = "datashare://Authority1/com.domainname.dataability.persondata";
573 
574     Uri uri1(uriBase + "/Person1");
575     Uri uri12(uriBase + "/Person1/2");
576     Uri uri13(uriBase + "/Person1/3");
577     Uri uri134(uriBase + "/Person1/3/4");
578     Uri uri135(uriBase + "/Person1/3/5");
579 
580     sptr<MockDataAbilityObserverStub> observer1(new (std::nothrow) MockDataAbilityObserverStub());
581     sptr<MockDataAbilityObserverStub> observer2(new (std::nothrow) MockDataAbilityObserverStub());
582 
583     RegisterObserverUtil(dataObsMgrInnerExt, uri1, observer1, 5, true);
584     RegisterObserverUtil(dataObsMgrInnerExt, uri12, observer1, 10, false);
585     RegisterObserverUtil(dataObsMgrInnerExt, uri13, observer1, 15, false);
586     RegisterObserverUtil(dataObsMgrInnerExt, uri134, observer1, 20, false);
587     RegisterObserverUtil(dataObsMgrInnerExt, uri135, observer1, 25, false);
588 
589     RegisterObserverUtil(dataObsMgrInnerExt, uri1, observer2, 25, true);
590     RegisterObserverUtil(dataObsMgrInnerExt, uri12, observer2, 20, false);
591     RegisterObserverUtil(dataObsMgrInnerExt, uri13, observer2, 15, true);
592     RegisterObserverUtil(dataObsMgrInnerExt, uri134, observer2, 10, false);
593     RegisterObserverUtil(dataObsMgrInnerExt, uri135, observer2, 5, false);
594 
595     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri12, uri13, uri134, uri135 } });
596     EXPECT_EQ(observer1->onChangeCall_, 95);
597     EXPECT_EQ(observer2->onChangeCall_, 205);
598     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(observer1), SUCCESS);
599     observer1->ReSet();
600     observer2->ReSet();
601     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri12, uri13, uri134, uri135 } });
602     EXPECT_EQ(observer1->onChangeCall_, 0);
603     EXPECT_EQ(observer2->onChangeCall_, 205);
604     EXPECT_EQ(dataObsMgrInnerExt->HandleUnregisterObserver(observer2), SUCCESS);
605     EXPECT_TRUE(dataObsMgrInnerExt->root_->childrens_.empty());
606 }
607 
608 /*
609  * Feature: DataObsMgrInnerExt
610  * Function: DeathRecipient test
611  * SubFunction: 0100
612  * FunctionPoints: NA
613  * EnvConditions: NA
614  * CaseDescription:DeathRecipient
615  */
616 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_DeathRecipient_0100, TestSize.Level1)
617 {
618     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
619     std::string uriBase = "datashare://Authority1/com.domainname.dataability.persondata";
620     Uri uri1(uriBase + "/Person1");
621     Uri uri12(uriBase + "/Person1/2");
622     Uri uri13(uriBase + "/Person1/3");
623     Uri uri134(uriBase + "/Person1/3/4");
624     Uri uri135(uriBase + "/Person1/3/5");
625 
626     sptr<MockDataAbilityObserverStub> observer1(new (std::nothrow) MockDataAbilityObserverStub());
627     sptr<MockDataAbilityObserverStub> observer2(new (std::nothrow) MockDataAbilityObserverStub());
628 
629     RegisterObserverUtil(dataObsMgrInnerExt, uri1, observer1, 5, true);
630     RegisterObserverUtil(dataObsMgrInnerExt, uri12, observer1, 10, false);
631     RegisterObserverUtil(dataObsMgrInnerExt, uri13, observer1, 15, false);
632     RegisterObserverUtil(dataObsMgrInnerExt, uri134, observer1, 20, false);
633     RegisterObserverUtil(dataObsMgrInnerExt, uri135, observer1, 25, false);
634 
635     RegisterObserverUtil(dataObsMgrInnerExt, uri1, observer2, 25, true);
636     RegisterObserverUtil(dataObsMgrInnerExt, uri12, observer2, 20, false);
637     RegisterObserverUtil(dataObsMgrInnerExt, uri13, observer2, 15, true);
638     RegisterObserverUtil(dataObsMgrInnerExt, uri134, observer2, 10, false);
639     RegisterObserverUtil(dataObsMgrInnerExt, uri135, observer2, 5, false);
640 
641     EXPECT_EQ(dataObsMgrInnerExt->obsRecipientRefs.size(), 2);
642     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri12, uri13, uri134, uri135 } });
643     EXPECT_EQ(observer1->onChangeCall_, 95);
644     EXPECT_EQ(observer2->onChangeCall_, 205);
645 
646     auto it = dataObsMgrInnerExt->obsRecipientRefs.find(observer1->AsObject());
647     EXPECT_TRUE(it != dataObsMgrInnerExt->obsRecipientRefs.end() && it->second->deathRecipient != nullptr);
648     it->second->deathRecipient->OnRemoteDied(observer1->AsObject());
649 
650     observer1->ReSet();
651     observer2->ReSet();
652     dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri1, uri12, uri13, uri134, uri135 } });
653     EXPECT_EQ(observer1->onChangeCall_, 0);
654     EXPECT_EQ(observer2->onChangeCall_, 205);
655     dataObsMgrInnerExt->OnCallBackDied(observer2->AsObject());
656     EXPECT_TRUE(dataObsMgrInnerExt->root_->childrens_.empty());
657     EXPECT_TRUE(dataObsMgrInnerExt->obsRecipientRefs.empty());
658 }
659 
660 /*
661  * Feature: DataObsMgrInnerExt
662  * Function: DeathRecipient test
663  * SubFunction: 0200
664  * FunctionPoints: NA
665  * EnvConditions: NA
666  * CaseDescription:DeathRecipient when dataObsMgrInnerExt release
667  */
668 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_DeathRecipient_0200, TestSize.Level1)
669 {
670     std::string uriBase = "datashare://Authority1/com.domainname.dataability.persondata";
671     Uri uri(uriBase + "/Person1");
672 
673     sptr<IRemoteObject::DeathRecipient> deathRecipient = nullptr;
674     sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
675     {
676         std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
677         EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, observer, false), SUCCESS);
678 
679         auto it = dataObsMgrInnerExt->obsRecipientRefs.find(observer->AsObject());
680         EXPECT_TRUE(it != dataObsMgrInnerExt->obsRecipientRefs.end() && it->second->deathRecipient != nullptr);
681         deathRecipient = it->second->deathRecipient;
682     }
683 
684     deathRecipient->OnRemoteDied(observer->AsObject());
685 }
686 
687 /*
688  * Feature: DataObsMgrInnerExt
689  * Function: AddObsDeathRecipient test
690  * SubFunction: 0800
691  * FunctionPoints: NA
692  * EnvConditions: NA
693  * CaseDescription:Add obs death recipient over max
694  */
695 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_AddObsDeathRecipientOverMax_0800, TestSize.Level1)
696 {
697     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
698     std::string uriBase = "datashare://Authority1/com.domainname.dataability.persondata";
699     Uri uri(uriBase + "/Person1");
700 
701     sptr<MockDataAbilityObserverStub> observer = (new (std::nothrow) MockDataAbilityObserverStub());
702     auto deathRecipientRef = std::make_shared<DataObsMgrInnerExt::DeathRecipientRef>(nullptr);
703     deathRecipientRef->ref = std::numeric_limits<uint32_t>::max() - 1;
704 
705     dataObsMgrInnerExt->obsRecipientRefs.emplace(observer, deathRecipientRef);
706 
707     EXPECT_TRUE(dataObsMgrInnerExt->AddObsDeathRecipient(observer));
708     deathRecipientRef->ref++;
709     EXPECT_FALSE(dataObsMgrInnerExt->AddObsDeathRecipient(observer));
710     EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, observer), DATAOBS_SERVICE_OBS_LIMMIT);
711 }
712 
713 /*
714  * Feature: DataObsMgrInnerExt
715  * Function: HandleRegisterObserver test
716  * SubFunction: 0800
717  * FunctionPoints: NA
718  * EnvConditions: NA
719  * CaseDescription:HandleRegisterObserver muti threads
720  */
721 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleRegisterObserver_0800, TestSize.Level1)
722 {
723     std::string uriBase = "datashare://Authority1/com.domainname.dataability.persondata";
724     std::vector<Uri> uris;
725     uris.emplace_back(uriBase + "/1");
726     uris.emplace_back(uriBase + "/2");
727     uris.emplace_back(uriBase + "/1/3");
728     uris.emplace_back(uriBase + "/2/4");
729     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
730 
731     auto func = [](std::vector<Uri> &uris, std::shared_ptr<DataObsMgrInnerExt> obsMgr,
__anonc404203c0202(std::vector<Uri> &uris, std::shared_ptr<DataObsMgrInnerExt> obsMgr, sptr<MockDataAbilityObserverStub> &obs) 732                     sptr<MockDataAbilityObserverStub> &obs) {
733         for (uint32_t i = 0; i < uris.size() * 5; ++i) {
734             EXPECT_EQ(obsMgr->HandleRegisterObserver(uris[i % uris.size()], obs, false), SUCCESS);
735         }
736         obs->Notify();
737     };
738 
739     sptr<MockDataAbilityObserverStub> observer1 = (new (std::nothrow) MockDataAbilityObserverStub());
740     std::thread thread1(std::bind(func, uris, dataObsMgrInnerExt, observer1));
741     thread1.detach();
742 
743     sptr<MockDataAbilityObserverStub> observer2 = (new (std::nothrow) MockDataAbilityObserverStub());
744     std::thread thread2(std::bind(func, uris, dataObsMgrInnerExt, observer2));
745     thread2.detach();
746 
747     observer1->Wait();
748     observer2->Wait();
749 
750     EXPECT_EQ(dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uris[0], uris[1] } }),
751         SUCCESS);
752     EXPECT_EQ(observer1->onChangeCall_, 10);
753     EXPECT_EQ(observer2->onChangeCall_, 10);
754     dataObsMgrInnerExt->HandleUnregisterObserver(observer1);
755 
756     observer1->ReSet();
757     observer2->ReSet();
758     EXPECT_EQ(dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uris[2], uris[3] } }),
759         SUCCESS);
760     EXPECT_EQ(observer1->onChangeCall_, 0);
761     EXPECT_EQ(observer2->onChangeCall_, 10);
762 }
763 
764 /*
765  * Feature: DataObsMgrInnerExt
766  * Function: HandleNotifyChange test
767  * SubFunction: 0100
768  * FunctionPoints: NA
769  * EnvConditions: NA
770  * CaseDescription:RegisterObserver when NotifyChange
771  */
772 HWTEST_F(DataObsMgrInnerExtTest, DataObsMgrInnerExt_HandleNotifyChange_0100, TestSize.Level1)
773 {
774     std::shared_ptr<DataObsMgrInnerExt> dataObsMgrInnerExt = std::make_shared<DataObsMgrInnerExt>();
775     std::string uriBase = "datashare://Authority1/com.domainname.dataability.persondata";
776     Uri uri(uriBase + "/Person");
777     auto sch = uri.GetScheme();
778 
779     sptr<MockDataAbilityObserverStub> observer1 = (new (std::nothrow) MockDataAbilityObserverStub());
780     sptr<MockDataAbilityObserverStub> observer2 = (new (std::nothrow) MockDataAbilityObserverStub());
781     dataObsMgrInnerExt->HandleRegisterObserver(uri, observer1);
782 
__anonc404203c0302() 783     observer1->func = [&dataObsMgrInnerExt, &observer2, &uri]() {
784         EXPECT_EQ(dataObsMgrInnerExt->HandleRegisterObserver(uri, observer2), SUCCESS);
785     };
786     EXPECT_EQ(dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri } }), SUCCESS);
787     EXPECT_EQ(observer1->onChangeCall_, 1);
788     observer1->func = nullptr;
789     EXPECT_EQ(dataObsMgrInnerExt->HandleNotifyChange({ ChangeInfo::ChangeType::INSERT, { uri } }), SUCCESS);
790     EXPECT_EQ(observer2->onChangeCall_, 1);
791 }
792 
793 } // namespace DataObsMgrInnerExtTest
794 } // namespace OHOS
795