1 /*
2 * Copyright (c) 2022 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
16 #include <gtest/gtest.h>
17
18 #define private public
19 #include "ability_manager_client.h"
20 #include "service_extension_context.h"
21 #undef private
22
23 #include "ability_connection.h"
24 #include "ability_manager_stub_mock.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::AppExecFwk;
28
29 namespace OHOS {
30 namespace AbilityRuntime {
31 class ServiceExtensionContextTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void ServiceExtensionContextTest::SetUpTestCase(void)
40 {}
TearDownTestCase(void)41 void ServiceExtensionContextTest::TearDownTestCase(void)
42 {}
SetUp(void)43 void ServiceExtensionContextTest::SetUp(void)
44 {}
TearDown(void)45 void ServiceExtensionContextTest::TearDown(void)
46 {}
47
48 /*
49 * Feature: ServiceExtensionContext
50 * Function: startAbility
51 * SubFunction: NA
52 * FunctionPoints: ServiceExtensionContextTest startAbility
53 * EnvConditions: NA
54 * CaseDescription: Verify startAbility
55 */
56 HWTEST_F(ServiceExtensionContextTest, service_extension_context_startAbility_001, TestSize.Level1)
57 {
58 ServiceExtensionContext serviceExtensionContextTest;
59 Want want;
60 ErrCode result = serviceExtensionContextTest.StartAbility(want);
61 EXPECT_EQ(ERR_IMPLICIT_START_ABILITY_FAIL, result);
62 }
63
64 /*
65 * Feature: ServiceExtensionContext
66 * Function: startAbility
67 * SubFunction: NA
68 * FunctionPoints: ServiceExtensionContextTest startAbility
69 * EnvConditions: NA
70 * CaseDescription: Verify startAbility
71 */
72 HWTEST_F(ServiceExtensionContextTest, service_extension_context_startAbility_002, TestSize.Level1)
73 {
74 ServiceExtensionContext serviceExtensionContextTest;
75 Want want;
76 StartOptions startOptions;
77 ErrCode result = serviceExtensionContextTest.StartAbility(want, startOptions);
78 EXPECT_EQ(ERR_IMPLICIT_START_ABILITY_FAIL, result);
79 }
80
81 /*
82 * Feature: ServiceExtensionContext
83 * Function: startAbility
84 * SubFunction: NA
85 * FunctionPoints: ServiceExtensionContextTest startAbility
86 * EnvConditions: NA
87 * CaseDescription: Verify startAbility
88 */
89 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityByCall_001, TestSize.Level1)
90 {
91 ServiceExtensionContext serviceExtensionContextTest;
92 Want want;
93 std::shared_ptr<CallerCallBack> callback = std::make_shared<CallerCallBack>();
94 ErrCode result = serviceExtensionContextTest.StartAbilityByCall(want, callback);
95 EXPECT_EQ(ERR_INVALID_VALUE, result);
96 }
97
98 /*
99 * Feature: ServiceExtensionContext
100 * Function: startAbility
101 * SubFunction: NA
102 * FunctionPoints: ServiceExtensionContextTest startAbility
103 * EnvConditions: NA
104 * CaseDescription: Verify startAbility
105 */
106 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ReleaseCall_001, TestSize.Level1)
107 {
108 ServiceExtensionContext serviceExtensionContextTest;
109 std::shared_ptr<CallerCallBack> callback = std::make_shared<CallerCallBack>();
110 ErrCode result = serviceExtensionContextTest.ReleaseCall(callback);
111 EXPECT_EQ(ERR_INVALID_VALUE, result);
112 }
113
114 /*
115 * Feature: ServiceExtensionContext
116 * Function: startAbility
117 * SubFunction: NA
118 * FunctionPoints: ServiceExtensionContextTest startAbility
119 * EnvConditions: NA
120 * CaseDescription: Verify startAbility
121 */
122 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ConnectAbility_001, TestSize.Level1)
123 {
124 ServiceExtensionContext serviceExtensionContextTest;
125 Want want;
126 sptr<AbilityConnectCallback> connectCallback;
127 ErrCode result = serviceExtensionContextTest.ConnectAbility(want, connectCallback);
128 EXPECT_EQ(ERR_INVALID_VALUE, result);
129 }
130
131 /*
132 * Feature: ServiceExtensionContext
133 * Function: startAbility
134 * SubFunction: NA
135 * FunctionPoints: ServiceExtensionContextTest startAbility
136 * EnvConditions: NA
137 * CaseDescription: Verify startAbility
138 */
139 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityWithAccount_001, TestSize.Level1)
140 {
141 ServiceExtensionContext serviceExtensionContextTest;
142 Want want;
143 int accountId = 1;
144 ErrCode result = serviceExtensionContextTest.StartAbilityWithAccount(want, accountId);
145 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
146 }
147
148 /*
149 * Feature: ServiceExtensionContext
150 * Function: startAbility
151 * SubFunction: NA
152 * FunctionPoints: ServiceExtensionContextTest startAbility
153 * EnvConditions: NA
154 * CaseDescription: Verify startAbility
155 */
156 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityWithAccount_002, TestSize.Level1)
157 {
158 ServiceExtensionContext serviceExtensionContextTest;
159 Want want;
160 int accountId = 1;
161 StartOptions startOptions;
162 ErrCode result = serviceExtensionContextTest.StartAbilityWithAccount(want, accountId, startOptions);
163 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
164 }
165
166 /*
167 * Feature: ServiceExtensionContext
168 * Function: startAbility
169 * SubFunction: NA
170 * FunctionPoints: ServiceExtensionContextTest StartServiceExtensionAbility
171 * EnvConditions: NA
172 * CaseDescription: Verify startAbility
173 */
174 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartServiceExtensionAbility_001, TestSize.Level1)
175 {
176 ServiceExtensionContext serviceExtensionContextTest;
177 Want want;
178 int32_t accountId = 1;
179 StartOptions startOptions;
180 ErrCode result = serviceExtensionContextTest.StartServiceExtensionAbility(want, accountId);
181 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
182 }
183
184 /*
185 * Feature: ServiceExtensionContext
186 * Function: startAbility
187 * SubFunction: NA
188 * FunctionPoints: ServiceExtensionContextTest StopServiceExtensionAbility
189 * EnvConditions: NA
190 * CaseDescription: Verify startAbility
191 */
192 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StopServiceExtensionAbility_001, TestSize.Level1)
193 {
194 ServiceExtensionContext serviceExtensionContextTest;
195 Want want;
196 int32_t accountId = 1;
197 StartOptions startOptions;
198 ErrCode result = serviceExtensionContextTest.StopServiceExtensionAbility(want, accountId);
199 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
200 }
201
202 /*
203 * Feature: ServiceExtensionContext
204 * Function: startAbility
205 * SubFunction: NA
206 * FunctionPoints: ServiceExtensionContextTest ConnectAbilityWithAccount
207 * EnvConditions: NA
208 * CaseDescription: Verify startAbility
209 */
210 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ConnectAbilityWithAccount_001, TestSize.Level1)
211 {
212 ServiceExtensionContext serviceExtensionContextTest;
213 Want want;
214 int32_t accountId = 1;
215 sptr<AbilityConnectCallback> connectCallback;
216 ErrCode result = serviceExtensionContextTest.ConnectAbilityWithAccount(want, accountId, connectCallback);
217 EXPECT_EQ(ERR_INVALID_VALUE, result);
218 }
219
220 /*
221 * Feature: ServiceExtensionContext
222 * Function: startAbility
223 * SubFunction: NA
224 * FunctionPoints: ServiceExtensionContextTest TerminateAbility
225 * EnvConditions: NA
226 * CaseDescription: Verify startAbility
227 */
228 HWTEST_F(ServiceExtensionContextTest, service_extension_context_TerminateAbility_001, TestSize.Level1)
229 {
230 ServiceExtensionContext serviceExtensionContextTest;
231 ErrCode result = serviceExtensionContextTest.TerminateAbility();
232 EXPECT_EQ(ERR_INVALID_VALUE, result);
233 }
234
235 /*
236 * Feature: ServiceExtensionContext
237 * Function: startAbility
238 * SubFunction: NA
239 * FunctionPoints: ServiceExtensionContextTest GetAbilityInfoType
240 * EnvConditions: NA
241 * CaseDescription: Verify startAbility
242 */
243 HWTEST_F(ServiceExtensionContextTest, service_extension_context_GetAbilityInfoType_001, TestSize.Level1)
244 {
245 ServiceExtensionContext serviceExtensionContextTest;
246 EXPECT_EQ(AppExecFwk::AbilityType::UNKNOWN, serviceExtensionContextTest.GetAbilityInfoType());
247 }
248
249 /**
250 * @tc.number: service_extension_context_startAbility_003
251 * @tc.name: StartAbility
252 * @tc.desc: Start ability success
253 */
254 HWTEST_F(ServiceExtensionContextTest, service_extension_context_startAbility_003, TestSize.Level1)
255 {
256 GTEST_LOG_(INFO) << "service_extension_context_startAbility_003 start";
257 ServiceExtensionContext serviceExtensionContextTest;
258 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
259 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
260
261 AAFwk::Want want;
262 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
263 want.SetElement(element);
264 auto ret = serviceExtensionContextTest.StartAbility(want);
265 EXPECT_EQ(ret, ERR_OK);
266 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
267 GTEST_LOG_(INFO) << "service_extension_context_startAbility_003 end";
268 }
269
270 /**
271 * @tc.number: service_extension_context_StartAbilityWithAccount_003
272 * @tc.name: StartAbility
273 * @tc.desc: Start ability with Account success
274 */
275 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityWithAccount_003, TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "service_extension_context_StartAbilityWithAccount_003 start";
278 ServiceExtensionContext serviceExtensionContextTest;
279 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
280 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
281
282 AAFwk::Want want;
283 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
284 want.SetElement(element);
285 int32_t accountId = 1;
286
287 auto ret = serviceExtensionContextTest.StartAbilityWithAccount(want, accountId);
288 EXPECT_EQ(ret, ERR_OK);
289 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
290 GTEST_LOG_(INFO) << "service_extension_context_StartAbilityWithAccount_003 end";
291 }
292
293 /**
294 * @tc.number: service_extension_context_StartServiceExtensionAbility_002
295 * @tc.name: StartAbility
296 * @tc.desc: Start service extension ability success
297 */
298 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartServiceExtensionAbility_002, TestSize.Level1)
299 {
300 GTEST_LOG_(INFO) << "service_extension_context_StartServiceExtensionAbility_002 start";
301 ServiceExtensionContext serviceExtensionContextTest;
302 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
303 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
304
305 AAFwk::Want want;
306 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
307 want.SetElement(element);
308 int32_t accountId = 1;
309
310 auto ret = serviceExtensionContextTest.StartServiceExtensionAbility(want, accountId);
311 EXPECT_EQ(ret, ERR_OK);
312 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
313 GTEST_LOG_(INFO) << "service_extension_context_StartServiceExtensionAbility_002 end";
314 }
315
316 /**
317 * @tc.number: service_extension_context_StopServiceExtensionAbility_002
318 * @tc.name: StopServiceExtensionAbility
319 * @tc.desc: Stop service extension ability success
320 */
321 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StopServiceExtensionAbility_002, TestSize.Level1)
322 {
323 GTEST_LOG_(INFO) << "service_extension_context_StopServiceExtensionAbility_002 start";
324 ServiceExtensionContext serviceExtensionContextTest;
325 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
326 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
327
328 AAFwk::Want want;
329 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
330 want.SetElement(element);
331 int32_t accountId = 1;
332
333 auto ret = serviceExtensionContextTest.StopServiceExtensionAbility(want, accountId);
334 EXPECT_EQ(ret, ERR_OK);
335 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
336 GTEST_LOG_(INFO) << "service_extension_context_StopServiceExtensionAbility_002 end";
337 }
338
339 /**
340 * @tc.number: service_extension_context_TerminateAbility_002
341 * @tc.name: TerminateAbility
342 * @tc.desc: Terminate ability success
343 */
344 HWTEST_F(ServiceExtensionContextTest, service_extension_context_TerminateAbility_002, TestSize.Level1)
345 {
346 GTEST_LOG_(INFO) << "service_extension_context_TerminateAbility_002 start";
347 ServiceExtensionContext serviceExtensionContextTest;
348 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
349 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
350
351 auto ret = serviceExtensionContextTest.TerminateAbility();
352 EXPECT_EQ(ret, ERR_OK);
353 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
354 GTEST_LOG_(INFO) << "service_extension_context_TerminateAbility_002 end";
355 }
356 }
357 }