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