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 <memory>
17 #include <algorithm>
18 #include <functional>
19 #include "uri.h"
20 #define private public
21 #include "data_ability_observer_proxy.h"
22 #include "dataobs_mgr_errors.h"
23 #include "dataobs_mgr_inner.h"
24 #include "mock_data_ability_observer_stub.h"
25
26 using namespace OHOS;
27 using namespace testing::ext;
28 using namespace testing;
29
30
31 namespace OHOS {
32 namespace AAFwk {
33 using Uri = OHOS::Uri;
34 using ObsListType = std::list<sptr<IDataAbilityObserver>>;
35 using ObsRecipientMapType = OHOS::AAFwk::DataObsMgrInner::ObsRecipientMapType;
36 class DataObsMgrInnerTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 std::shared_ptr<DataObsMgrInner> dataObsMgrInner_ = nullptr;
43 };
SetUpTestCase(void)44 void DataObsMgrInnerTest::SetUpTestCase(void) {}
TearDownTestCase(void)45 void DataObsMgrInnerTest::TearDownTestCase(void) {}
SetUp()46 void DataObsMgrInnerTest::SetUp()
47 {
48 dataObsMgrInner_ = std::make_shared<DataObsMgrInner>();
49 }
TearDown()50 void DataObsMgrInnerTest::TearDown() {}
51
52 /*
53 * Feature: DataObsMgrInner
54 * Function: Register and unregister function test
55 * SubFunction: HandleRegisterObserver/HandleRegisterObserver
56 * FunctionPoints: NA
57 * EnvConditions: NA
58 * CaseDescription:NA
59 */
60 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleRegisterObserver_0100, TestSize.Level1)
61 {
62 if (dataObsMgrInner_ == nullptr) {
63 return;
64 }
65
66 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
67 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
68
69 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
70 dataObsMgrInner_->HandleRegisterObserver(uri, callback);
71
72 EXPECT_EQ(dataObsMgrInner_->HaveRegistered(callback), true);
73 dataObsMgrInner_->HandleUnregisterObserver(uri, callback);
74 EXPECT_EQ(dataObsMgrInner_->HaveRegistered(callback), false);
75 }
76
77 /*
78 * Feature: DataObsMgrInner
79 * Function: Register function test
80 * SubFunction: HandleRegisterObserver
81 * FunctionPoints: NA
82 * EnvConditions: NA
83 * CaseDescription:NA
84 */
85 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleRegisterObserver_0200, TestSize.Level1)
86 {
87 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
88 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
89 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
90 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
91 ObsListType obsList;
92 obsList.push_back(callback);
93 dataObsMgrInner->observers_.emplace(uri.ToString(), obsList);
94 int res = dataObsMgrInner->HandleRegisterObserver(uri, callback);
95 EXPECT_EQ(res, OBS_EXIST);
96 }
97
98 /*
99 * Feature: DataObsMgrInner
100 * Function: Register function test
101 * SubFunction: HandleRegisterObserver
102 * FunctionPoints: NA
103 * EnvConditions: NA
104 * CaseDescription:NA
105 */
106 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleRegisterObserver_0300, TestSize.Level1)
107 {
108 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
109 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
110 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
111 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
112 const sptr<IDataAbilityObserver> callback1(new (std::nothrow) DataAbilityObserverProxy(observer));
113 ObsListType obsList;
114 obsList.push_back(callback1);
115 dataObsMgrInner->observers_.emplace(uri.ToString(), obsList);
116 int res = dataObsMgrInner->HandleRegisterObserver(uri, callback);
117 EXPECT_EQ(res, OBS_EXIST);
118 }
119
120 /*
121 * Feature: DataObsMgrInner
122 * Function: Unregister function test
123 * SubFunction: HandleUnregisterObserver
124 * FunctionPoints: NA
125 * EnvConditions: NA
126 * CaseDescription:NA
127 */
128 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleUnregisterObserver_0100, TestSize.Level1)
129 {
130 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
131 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
132 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
133 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
134 dataObsMgrInner->observers_.clear();
135 int res = dataObsMgrInner->HandleUnregisterObserver(uri, callback);
136 EXPECT_EQ(res, NO_OBS_FOR_URI);
137 }
138
139 /*
140 * Feature: DataObsMgrInner
141 * Function: Unregister function test
142 * SubFunction: HandleUnregisterObserver
143 * FunctionPoints: NA
144 * EnvConditions: NA
145 * CaseDescription:NA
146 */
147 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleUnregisterObserver_0200, TestSize.Level1)
148 {
149 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
150 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
151 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
152 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
153 ObsListType obsList;
154 obsList.push_back(callback);
155 dataObsMgrInner->observers_.emplace(uri.ToString(), obsList);
156 int res = dataObsMgrInner->HandleUnregisterObserver(uri, callback);
157 EXPECT_EQ(res, NO_ERROR);
158 }
159
160 /*
161 * Feature: DataObsMgrInner
162 * Function: Unregister function test
163 * SubFunction: HandleUnregisterObserver
164 * FunctionPoints: NA
165 * EnvConditions: NA
166 * CaseDescription:NA
167 */
168 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleUnregisterObserver_0300, TestSize.Level1)
169 {
170 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
171 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
172 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
173 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
174 const sptr<IDataAbilityObserver> callback2(new (std::nothrow) DataAbilityObserverProxy(observer));
175 ObsListType obsList;
176 obsList.push_back(callback);
177 obsList.push_back(callback2);
178 dataObsMgrInner->observers_.emplace(uri.ToString(), obsList);
179 dataObsMgrInner->observers_.emplace("exit", obsList);
180 int res = dataObsMgrInner->HandleUnregisterObserver(uri, callback);
181 EXPECT_EQ(res, NO_ERROR);
182 }
183
184 /*
185 * Feature: DataObsMgrInner
186 * Function: Register and unregister function test
187 * SubFunction: OnChange
188 * FunctionPoints: When the data changes, call the OnChange function of the registered dataabilityobserver
189 * EnvConditions: NA
190 * CaseDescription:NA
191 */
192 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleNotifyChange_0100, TestSize.Level1)
193 {
194 if (dataObsMgrInner_ == nullptr) {
195 return;
196 }
197 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
198 sptr<MockDataAbilityObserverStub> mockDataAbilityObserverStub(new (std::nothrow) MockDataAbilityObserverStub());
199
200 EXPECT_CALL(*mockDataAbilityObserverStub, OnChange()).Times(1);
201
202 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(mockDataAbilityObserverStub));
203 dataObsMgrInner_->HandleRegisterObserver(uri, callback);
204 dataObsMgrInner_->HandleNotifyChange(uri);
205 }
206
207 /*
208 * Feature: DataObsMgrInner
209 * Function: Unregister function test
210 * SubFunction: HandleUnregisterObserver
211 * FunctionPoints: NA
212 * EnvConditions: NA
213 * CaseDescription:NA
214 */
215 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleNotifyChange_0200, TestSize.Level1)
216 {
217 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
218 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
219 dataObsMgrInner->observers_.clear();
220 int res = dataObsMgrInner->HandleNotifyChange(uri);
221 EXPECT_EQ(res, NO_OBS_FOR_URI);
222 }
223
224 /*
225 * Feature: DataObsMgrInner
226 * Function: Unregister function test
227 * SubFunction: HandleUnregisterObserver
228 * FunctionPoints: NA
229 * EnvConditions: NA
230 * CaseDescription:NA
231 */
232 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_HandleNotifyChange_0300, TestSize.Level1)
233 {
234 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
235 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
236 ObsListType obsList;
237 obsList.push_back(nullptr);
238 dataObsMgrInner->observers_.emplace(uri.ToString(), obsList);
239 int res = dataObsMgrInner->HandleNotifyChange(uri);
240 EXPECT_EQ(res, NO_ERROR);
241 }
242
243 /*
244 * Feature: DataObsMgrInner
245 * Function: GetObsListFromMap/RemoveObs/HaveRegistered function test
246 * SubFunction: NA
247 * FunctionPoints: NA
248 * EnvConditions: NA
249 * CaseDescription:NA
250 */
251 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_RemoveObs_HaveRegistered_0100, TestSize.Level1)
252 {
253 if (dataObsMgrInner_ == nullptr) {
254 return;
255 }
256 Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
257 sptr<MockDataAbilityObserverStub> mockDataAbilityObserverStub(new (std::nothrow) MockDataAbilityObserverStub());
258 const sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(mockDataAbilityObserverStub));
259 dataObsMgrInner_->HandleRegisterObserver(uri, callback);
260
261 sptr<MockDataAbilityObserverStub> mockDataAbilityObserverStub2(new (std::nothrow) MockDataAbilityObserverStub());
262 const sptr<IDataAbilityObserver> callback2(
263 new (std::nothrow) DataAbilityObserverProxy(mockDataAbilityObserverStub2));
264
265 dataObsMgrInner_->HandleRegisterObserver(uri, callback2);
266 auto obsPair = dataObsMgrInner_->observers_.find(uri.ToString());
267 EXPECT_EQ((std::size_t)2, obsPair->second.size());
268 EXPECT_EQ(true, dataObsMgrInner_->HaveRegistered(callback));
269 EXPECT_EQ(true, dataObsMgrInner_->HaveRegistered(callback2));
270
271 dataObsMgrInner_->RemoveObs(callback->AsObject());
272 EXPECT_EQ(false, dataObsMgrInner_->HaveRegistered(callback));
273 obsPair->second.clear();
274 obsPair = dataObsMgrInner_->observers_.find(uri.ToString());
275 EXPECT_EQ(false, dataObsMgrInner_->HaveRegistered(callback));
276
277 dataObsMgrInner_->RemoveObs(callback2->AsObject());
278 EXPECT_EQ(false, dataObsMgrInner_->HaveRegistered(callback2));
279 obsPair->second.clear();
280 obsPair = dataObsMgrInner_->observers_.find(uri.ToString());
281 EXPECT_EQ(false, dataObsMgrInner_->HaveRegistered(callback2));
282 }
283
284 /*
285 * Feature: DataObsMgrInner
286 * Function: AddObsDeathRecipient/RemoveObsDeathRecipient function test
287 * SubFunction: NA
288 * FunctionPoints: NA
289 * EnvConditions: NA
290 * CaseDescription:NA
291 */
292 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_AddRemove_ObsDeathRecipient_0100, TestSize.Level1)
293 {
294 if (dataObsMgrInner_ == nullptr) {
295 return;
296 }
297
298 sptr<IRemoteObject> observer(new (std::nothrow) MockDataAbilityObserverStub());
299 sptr<IDataAbilityObserver> callback(new (std::nothrow) DataAbilityObserverProxy(observer));
300 dataObsMgrInner_->AddObsDeathRecipient(callback);
301 dataObsMgrInner_->AddObsDeathRecipient(nullptr);
302
303 ObsRecipientMapType::const_iterator it;
304 it = dataObsMgrInner_->obsRecipient_.find(observer);
305 EXPECT_EQ(true, it != dataObsMgrInner_->obsRecipient_.end());
306
307 dataObsMgrInner_->RemoveObsDeathRecipient(callback->AsObject());
308 dataObsMgrInner_->RemoveObsDeathRecipient(nullptr);
309 it = dataObsMgrInner_->obsRecipient_.find(observer);
310 EXPECT_EQ(false, it != dataObsMgrInner_->obsRecipient_.end());
311
312 dataObsMgrInner_->obsRecipient_.clear();
313 dataObsMgrInner_->RemoveObsDeathRecipient(callback->AsObject());
314 }
315
316 /*
317 * Feature: DataObsMgrInner
318 * Function: Unregister function test
319 * SubFunction: RemoveObs
320 * FunctionPoints: NA
321 * EnvConditions: NA
322 * CaseDescription:NA
323 */
324 HWTEST_F(DataObsMgrInnerTest, DataObsMgrInner_RemoveObs_0100, TestSize.Level1)
325 {
326 std::shared_ptr<DataObsMgrInner> dataObsMgrInner = std::make_shared<DataObsMgrInner>();
327 ASSERT_NE(dataObsMgrInner, nullptr);
328 std::string uri1 = "uri1";
329 std::string uri2 = "uri2";
330 sptr<MockDataAbilityObserverStub> observer(new (std::nothrow) MockDataAbilityObserverStub());
331 const sptr<IDataAbilityObserver> callback1(new (std::nothrow) DataAbilityObserverProxy(observer));
332 const sptr<IDataAbilityObserver> callback2(new (std::nothrow) DataAbilityObserverProxy(observer));
333 ObsListType obsList1;
334 ObsListType obsList2;
335 ObsListType obsList3;
336 obsList1.push_back(callback1);
337 obsList2.push_back(callback1);
338 obsList2.push_back(callback2);
339 dataObsMgrInner->observers_.emplace(uri1, obsList1);
340 dataObsMgrInner->observers_.emplace(uri2, obsList2);
341 dataObsMgrInner->RemoveObs(callback2->AsObject());
342 }
343 } // namespace AAFwk
344 } // namespace OHOS
345