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 <memory>
16 
17 #include "gtest/gtest.h"
18 #include "gmock/gmock.h"
19 
20 #include "mock_data_obs_mgr_stub.h"
21 
22 #include "dataobs_mgr_proxy.h"
23 
24 namespace OHOS {
25 namespace AAFwk {
26 using namespace testing::ext;
27 class DataObsManagerStubTest : public testing::Test {
28 public:
29     DataObsManagerStubTest() = default;
30     virtual ~DataObsManagerStubTest() = default;
31 
32     static void SetUpTestCase(void);
33     static void TearDownTestCase(void);
34     void SetUp();
35     void TearDown();
36 };
SetUpTestCase(void)37 void DataObsManagerStubTest::SetUpTestCase(void)
38 {}
TearDownTestCase(void)39 void DataObsManagerStubTest::TearDownTestCase(void)
40 {}
SetUp()41 void DataObsManagerStubTest::SetUp()
42 {}
TearDown()43 void DataObsManagerStubTest::TearDown()
44 {}
45 
46 /*
47  * Feature: DataObsManagerStub
48  * Function: OnRemoteRequest
49  * SubFunction: NA
50  * FunctionPoints: DataObsManagerStub OnRemoteRequest
51  * EnvConditions: NA
52  * CaseDescription: Verify that the DataObsManagerStub OnRemoteRequest is normal.
53  */
54 HWTEST_F(DataObsManagerStubTest, AaFwk_DataObsManagerStubTest_OnRemoteRequest_0100, TestSize.Level1)
55 {
56     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_OnRemoteRequest_0100 start";
57     std::shared_ptr<MockDataObsMgrStub> dataobs = std::make_shared<MockDataObsMgrStub>();
58     uint32_t code = IDataObsMgr::TRANS_BUTT + 1;
59     MessageParcel data;
60     MessageParcel reply;
61     MessageOption option;
62 
63     if (!data.WriteInterfaceToken(DataObsManagerProxy::GetDescriptor())) {
64         GTEST_LOG_(ERROR) << "---------- WriteInterfaceToken(data) retval is false end";
65         return;
66     }
67 
68     const int retval = dataobs->OnRemoteRequest(code, data, reply, option);
69 
70     EXPECT_EQ(TEST_RETVAL_ONREMOTEREQUEST, retval);
71     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_OnRemoteRequest_0100 end";
72 }
73 
74 /*
75  * Feature: DataObsManagerStub
76  * Function: OnRemoteRequest
77  * SubFunction: NA
78  * FunctionPoints: DataObsManagerStub OnRemoteRequest
79  * EnvConditions: NA
80  * CaseDescription: Verify that the DataObsManagerStub OnRemoteRequest is normal.
81  */
82 HWTEST_F(DataObsManagerStubTest, AaFwk_DataObsManagerStubTest_RegisterObserver_0100, TestSize.Level1)
83 {
84     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_RegisterObserver_0100 start";
85     const int testVal1 = static_cast<int>(NO_ERROR);
86     const int testVal2 = static_cast<int>(TEST_RETVAL_ONREMOTEREQUEST);
87     std::shared_ptr<MockDataObsMgrStub> dataobs = std::make_shared<MockDataObsMgrStub>();
88     sptr<AAFwk::IDataAbilityObserver> dataObserver(new (std::nothrow) MockDataAbilityObserverStub());
89     Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
90     uint32_t code = IDataObsMgr::REGISTER_OBSERVER;
91     MessageParcel data;
92     MessageParcel reply;
93     MessageOption option;
94 
95     if (!data.WriteInterfaceToken(DataObsManagerProxy::GetDescriptor())) {
96         GTEST_LOG_(ERROR) << "---------- WriteInterfaceToken(data) retval is false end";
97         return;
98     }
99     if (!data.WriteString(uri.ToString())) {
100         GTEST_LOG_(ERROR) << "---------- data.WriteParcelable(uri) retval is false end";
101         return;
102     }
103     if (dataObserver == nullptr) {
104         return;
105     }
106 
107     if (!data.WriteParcelable(dataObserver->AsObject())) {
108         GTEST_LOG_(ERROR) << "---------- data.WriteParcelable(dataObserver->AsObject()) retval is false end";
109         return;
110     }
111 
112     EXPECT_CALL(*dataobs, RegisterObserver(testing::_, testing::_)).Times(1).WillOnce(testing::Return(testVal2));
113 
114     const int retval1 = dataobs->OnRemoteRequest(code, data, reply, option);
115     const int retval2 = reply.ReadInt32();
116 
117     EXPECT_EQ(testVal1, retval1);
118     EXPECT_EQ(testVal2, retval2);
119     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_RegisterObserver_0100 end";
120 }
121 
122 /*
123  * Feature: DataObsManagerStub
124  * Function: UnregisterObserver
125  * SubFunction: NA
126  * FunctionPoints: DataObsManagerStub UnregisterObserver
127  * EnvConditions: NA
128  * CaseDescription: Verify that the DataObsManagerStub UnregisterObserver is normal.
129  */
130 HWTEST_F(DataObsManagerStubTest, AaFwk_DataObsManagerStubTest_UnregisterObserver_0100, TestSize.Level1)
131 {
132     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_UnregisterObserver_0100 start";
133     const int testVal1 = static_cast<int>(NO_ERROR);
134     const int testVal2 = static_cast<int>(TEST_RETVAL_ONREMOTEREQUEST);
135     std::shared_ptr<MockDataObsMgrStub> dataobs = std::make_shared<MockDataObsMgrStub>();
136     sptr<AAFwk::IDataAbilityObserver> dataObserver(new (std::nothrow) MockDataAbilityObserverStub());
137 
138     Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
139     uint32_t code = IDataObsMgr::UNREGISTER_OBSERVER;
140     MessageParcel data;
141     MessageParcel reply;
142     MessageOption option;
143 
144     if (!data.WriteInterfaceToken(DataObsManagerProxy::GetDescriptor())) {
145         GTEST_LOG_(ERROR) << "---------- WriteInterfaceToken(data) retval is false end";
146         return;
147     }
148     if (!data.WriteString(uri.ToString())) {
149         GTEST_LOG_(ERROR) << "---------- data.WriteParcelable(uri) retval is false end";
150         return;
151     }
152     if (dataObserver == nullptr) {
153         return;
154     }
155 
156     if (!data.WriteParcelable(dataObserver->AsObject())) {
157         GTEST_LOG_(ERROR) << "---------- data.WriteParcelable(dataObserver->AsObject()) retval is false end";
158         return;
159     }
160 
161     EXPECT_CALL(*dataobs, UnregisterObserver(testing::_, testing::_)).Times(1).WillOnce(testing::Return(testVal2));
162 
163     const int retval1 = dataobs->OnRemoteRequest(code, data, reply, option);
164     const int retval2 = reply.ReadInt32();
165 
166     EXPECT_EQ(testVal1, retval1);
167     EXPECT_EQ(testVal2, retval2);
168     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_UnregisterObserver_0100 end";
169 }
170 
171 /*
172  * Feature: DataObsManagerStub
173  * Function: NotifyChange
174  * SubFunction: NA
175  * FunctionPoints: DataObsManagerStub NotifyChange
176  * EnvConditions: NA
177  * CaseDescription: Verify that the DataObsManagerStub NotifyChange is normal.
178  */
179 HWTEST_F(DataObsManagerStubTest, AaFwk_DataObsManagerStubTest_NotifyChange_0100, TestSize.Level1)
180 {
181     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_NotifyChange_0100 start";
182     std::shared_ptr<MockDataObsMgrStub> dataobs = std::make_shared<MockDataObsMgrStub>();
183     Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
184     const int testVal1 = static_cast<int>(NO_ERROR);
185     const int testVal2 = static_cast<int>(TEST_RETVAL_ONREMOTEREQUEST);
186     uint32_t code = IDataObsMgr::NOTIFY_CHANGE;
187     MessageParcel data;
188     MessageParcel reply;
189     MessageOption option;
190 
191     if (!data.WriteInterfaceToken(DataObsManagerProxy::GetDescriptor())) {
192         GTEST_LOG_(ERROR) << "---------- WriteInterfaceToken(data) retval is false end";
193         return;
194     }
195     if (!data.WriteString(uri.ToString())) {
196         GTEST_LOG_(ERROR) << "---------- data.WriteParcelable(uri) retval is false end";
197         return;
198     }
199 
200     EXPECT_CALL(*dataobs, NotifyChange(testing::_)).Times(1).WillOnce(testing::Return(testVal2));
201 
202     const int retval1 = dataobs->OnRemoteRequest(code, data, reply, option);
203     const int retval2 = reply.ReadInt32();
204 
205     EXPECT_EQ(testVal1, retval1);
206     EXPECT_EQ(testVal2, retval2);
207     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_NotifyChange_0100 end";
208 }
209 
210 /*
211  * Feature: DataObsManagerStub
212  * Function: RegisterObserverExtInner
213  * SubFunction: NA
214  * FunctionPoints: DataObsManagerStub RegisterObserverExtInner
215  * EnvConditions: NA
216  * CaseDescription: Verify that the DataObsManagerStub RegisterObserverExtInner is normal.
217  */
218 HWTEST_F(DataObsManagerStubTest, AaFwk_DataObsManagerStubTest_RegisterObserverExtInner_0100, TestSize.Level1)
219 {
220     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_RegisterObserverExtInner_0100 start";
221     std::shared_ptr<MockDataObsMgrStub> dataobs = std::make_shared<MockDataObsMgrStub>();
222     Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
223     const int testVal1 = static_cast<int>(NO_ERROR);
224     const Status testVal2 = SUCCESS;
225     uint32_t code = IDataObsMgr::REGISTER_OBSERVER_EXT;
226     MessageParcel data;
227     MessageParcel reply;
228     MessageOption option;
229 
230     if (!data.WriteInterfaceToken(DataObsManagerProxy::GetDescriptor())) {
231         GTEST_LOG_(ERROR) << "---------- WriteInterfaceToken(data) retval is false end";
232         return;
233     }
234     if (!data.WriteString(uri.ToString())) {
235         GTEST_LOG_(ERROR) << "---------- data.WriteParcelable(uri) retval is false end";
236         return;
237     }
238 
239     EXPECT_CALL(*dataobs, RegisterObserverExt(testing::_, testing::_, testing::_)).Times(1)
240         .WillOnce(testing::Return(testVal2));
241 
242     const int retval1 = dataobs->OnRemoteRequest(code, data, reply, option);
243     const int retval2 = reply.ReadInt32();
244 
245     EXPECT_EQ(testVal1, retval1);
246     EXPECT_EQ(testVal2, retval2);
247     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_RegisterObserverExtInner_0100 end";
248 }
249 
250 /*
251  * Feature: DataObsManagerStub
252  * Function: UnregisterObserverExtInner
253  * SubFunction: NA
254  * FunctionPoints: DataObsManagerStub UnregisterObserverExtInner
255  * EnvConditions: NA
256  * CaseDescription: Verify that the DataObsManagerStub UnregisterObserverExtInner is normal.
257  */
258 HWTEST_F(DataObsManagerStubTest, AaFwk_DataObsManagerStubTest_UnregisterObserverExtInner_0100, TestSize.Level1)
259 {
260     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_UnregisterObserverExtInner_0100 start";
261     std::shared_ptr<MockDataObsMgrStub> dataobs = std::make_shared<MockDataObsMgrStub>();
262     Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
263     const int testVal1 = static_cast<int>(NO_ERROR);
264     const Status testVal2 = SUCCESS;
265     uint32_t code = IDataObsMgr::UNREGISTER_OBSERVER_EXT;
266     MessageParcel data;
267     MessageParcel reply;
268     MessageOption option;
269 
270     if (!data.WriteInterfaceToken(DataObsManagerProxy::GetDescriptor())) {
271         GTEST_LOG_(ERROR) << "---------- WriteInterfaceToken(data) retval is false end";
272         return;
273     }
274     if (!data.WriteString(uri.ToString())) {
275         GTEST_LOG_(ERROR) << "---------- data.WriteParcelable(uri) retval is false end";
276         return;
277     }
278 
279     EXPECT_CALL(*dataobs, UnregisterObserverExt(testing::_, testing::_)).Times(1).WillOnce(testing::Return(testVal2));
280 
281     const int retval1 = dataobs->OnRemoteRequest(code, data, reply, option);
282     const int retval2 = reply.ReadInt32();
283 
284     EXPECT_EQ(testVal1, retval1);
285     EXPECT_EQ(testVal2, retval2);
286     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_UnregisterObserverExtInner_0100 end";
287 }
288 
289 /*
290  * Feature: DataObsManagerStub
291  * Function: UnregisterObserverExtALLInner
292  * SubFunction: NA
293  * FunctionPoints: DataObsManagerStub UnregisterObserverExtALLInner
294  * EnvConditions: NA
295  * CaseDescription: Verify that the DataObsManagerStub UnregisterObserverExtALLInner is normal.
296  */
297 HWTEST_F(DataObsManagerStubTest, AaFwk_DataObsManagerStubTest_UnregisterObserverExtALLInner_0100, TestSize.Level1)
298 {
299     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_UnregisterObserverExtALLInner_0100 start";
300     std::shared_ptr<MockDataObsMgrStub> dataobs = std::make_shared<MockDataObsMgrStub>();
301     Uri uri("dataability://device_id/com.domainname.dataability.persondata/person/10");
302     const int testVal1 = static_cast<int>(NO_ERROR);
303     const Status testVal2 = SUCCESS;
304     uint32_t code = IDataObsMgr::UNREGISTER_OBSERVER_ALL_EXT;
305     MessageParcel data;
306     MessageParcel reply;
307     MessageOption option;
308 
309     if (!data.WriteInterfaceToken(DataObsManagerProxy::GetDescriptor())) {
310         GTEST_LOG_(ERROR) << "---------- WriteInterfaceToken(data) retval is false end";
311         return;
312     }
313     if (!data.WriteString(uri.ToString())) {
314         GTEST_LOG_(ERROR) << "---------- data.WriteParcelable(uri) retval is false end";
315         return;
316     }
317 
318     EXPECT_CALL(*dataobs, UnregisterObserverExt(testing::_)).Times(1).WillOnce(testing::Return(testVal2));
319 
320     const int retval1 = dataobs->OnRemoteRequest(code, data, reply, option);
321     const int retval2 = reply.ReadInt32();
322 
323     EXPECT_EQ(testVal1, retval1);
324     EXPECT_EQ(testVal2, retval2);
325     GTEST_LOG_(INFO) << "AaFwk_DataObsManagerStubTest_UnregisterObserverExtALLInner_0100 end";
326 }
327 }  // namespace AAFwk
328 }  // namespace OHOS
329