1 /*
2 * Copyright (c) 2022-2023 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 StartAbilityAsCaller
86 * EnvConditions: NA
87 * CaseDescription: Verify startAbility
88 */
89 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityAsCaller_001, TestSize.Level1)
90 {
91 ServiceExtensionContext serviceExtensionContextTest;
92 Want want;
93 ErrCode result = serviceExtensionContextTest.StartAbilityAsCaller(want);
94 GTEST_LOG_(INFO) << result;
95 EXPECT_EQ(ERR_IMPLICIT_START_ABILITY_FAIL, result);
96 }
97
98 /*
99 * Feature: ServiceExtensionContext
100 * Function: startAbility
101 * SubFunction: NA
102 * FunctionPoints: ServiceExtensionContextTest StartAbilityAsCaller
103 * EnvConditions: NA
104 * CaseDescription: Verify startAbility
105 */
106 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityAsCaller_002, TestSize.Level1)
107 {
108 ServiceExtensionContext serviceExtensionContextTest;
109 Want want;
110 StartOptions startOptions;
111 ErrCode result = serviceExtensionContextTest.StartAbilityAsCaller(want, startOptions);
112 GTEST_LOG_(INFO) << result;
113 EXPECT_EQ(ERR_IMPLICIT_START_ABILITY_FAIL, result);
114 }
115
116 /*
117 * Feature: ServiceExtensionContext
118 * Function: startAbility
119 * SubFunction: NA
120 * FunctionPoints: ServiceExtensionContextTest startAbility
121 * EnvConditions: NA
122 * CaseDescription: Verify startAbility
123 */
124 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityByCall_001, TestSize.Level1)
125 {
126 ServiceExtensionContext serviceExtensionContextTest;
127 Want want;
128 std::shared_ptr<CallerCallBack> callback = std::make_shared<CallerCallBack>();
129 ErrCode result = serviceExtensionContextTest.StartAbilityByCall(want, callback);
130 EXPECT_EQ(ERR_INVALID_VALUE, result);
131 }
132
133 /*
134 * Feature: ServiceExtensionContext
135 * Function: startAbility
136 * SubFunction: NA
137 * FunctionPoints: ServiceExtensionContextTest startAbility
138 * EnvConditions: NA
139 * CaseDescription: Verify startAbility
140 */
141 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ReleaseCall_001, TestSize.Level1)
142 {
143 ServiceExtensionContext serviceExtensionContextTest;
144 std::shared_ptr<CallerCallBack> callback = std::make_shared<CallerCallBack>();
145 ErrCode result = serviceExtensionContextTest.ReleaseCall(callback);
146 EXPECT_EQ(ERR_INVALID_VALUE, result);
147 }
148
149 /*
150 * Feature: ServiceExtensionContext
151 * Function: startAbility
152 * SubFunction: NA
153 * FunctionPoints: ServiceExtensionContextTest startAbility
154 * EnvConditions: NA
155 * CaseDescription: Verify startAbility
156 */
157 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ConnectAbility_001, TestSize.Level1)
158 {
159 ServiceExtensionContext serviceExtensionContextTest;
160 Want want;
161 sptr<AbilityConnectCallback> connectCallback;
162 ErrCode result = serviceExtensionContextTest.ConnectAbility(want, connectCallback);
163 EXPECT_EQ(AAFwk::ERR_INVALID_CALLER, result);
164 }
165
166 /*
167 * Feature: ServiceExtensionContext
168 * Function: startAbility
169 * SubFunction: NA
170 * FunctionPoints: ServiceExtensionContextTest startAbility
171 * EnvConditions: NA
172 * CaseDescription: Verify startAbility
173 */
174 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityWithAccount_001, TestSize.Level1)
175 {
176 ServiceExtensionContext serviceExtensionContextTest;
177 Want want;
178 int accountId = 1;
179 ErrCode result = serviceExtensionContextTest.StartAbilityWithAccount(want, accountId);
180 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
181 }
182
183 /*
184 * Feature: ServiceExtensionContext
185 * Function: startAbility
186 * SubFunction: NA
187 * FunctionPoints: ServiceExtensionContextTest startAbility
188 * EnvConditions: NA
189 * CaseDescription: Verify startAbility
190 */
191 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityWithAccount_002, TestSize.Level1)
192 {
193 ServiceExtensionContext serviceExtensionContextTest;
194 Want want;
195 int accountId = 1;
196 StartOptions startOptions;
197 ErrCode result = serviceExtensionContextTest.StartAbilityWithAccount(want, accountId, startOptions);
198 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
199 }
200
201 /*
202 * Feature: ServiceExtensionContext
203 * Function: startAbility
204 * SubFunction: NA
205 * FunctionPoints: ServiceExtensionContextTest StartServiceExtensionAbility
206 * EnvConditions: NA
207 * CaseDescription: Verify startAbility
208 */
209 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartServiceExtensionAbility_001, TestSize.Level1)
210 {
211 ServiceExtensionContext serviceExtensionContextTest;
212 Want want;
213 int32_t accountId = 1;
214 StartOptions startOptions;
215 ErrCode result = serviceExtensionContextTest.StartServiceExtensionAbility(want, accountId);
216 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
217 }
218
219 /*
220 * Feature: ServiceExtensionContext
221 * Function: startAbility
222 * SubFunction: NA
223 * FunctionPoints: ServiceExtensionContextTest StopServiceExtensionAbility
224 * EnvConditions: NA
225 * CaseDescription: Verify startAbility
226 */
227 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StopServiceExtensionAbility_001, TestSize.Level1)
228 {
229 ServiceExtensionContext serviceExtensionContextTest;
230 Want want;
231 int32_t accountId = 1;
232 StartOptions startOptions;
233 ErrCode result = serviceExtensionContextTest.StopServiceExtensionAbility(want, accountId);
234 EXPECT_EQ(CHECK_PERMISSION_FAILED, result);
235 }
236
237 /*
238 * Feature: ServiceExtensionContext
239 * Function: startAbility
240 * SubFunction: NA
241 * FunctionPoints: ServiceExtensionContextTest ConnectAbilityWithAccount
242 * EnvConditions: NA
243 * CaseDescription: Verify startAbility
244 */
245 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ConnectAbilityWithAccount_001, TestSize.Level1)
246 {
247 ServiceExtensionContext serviceExtensionContextTest;
248 Want want;
249 int32_t accountId = 1;
250 sptr<AbilityConnectCallback> connectCallback;
251 ErrCode result = serviceExtensionContextTest.ConnectAbilityWithAccount(want, accountId, connectCallback);
252 EXPECT_EQ(AAFwk::ERR_INVALID_CALLER, result);
253 }
254
255 /*
256 * Feature: ServiceExtensionContext
257 * Function: startAbility
258 * SubFunction: NA
259 * FunctionPoints: ServiceExtensionContextTest ConnectAbilityWithAccount
260 * EnvConditions: NA
261 * CaseDescription: Verify startAbility
262 */
263 HWTEST_F(ServiceExtensionContextTest, service_extension_context_DisconnectAbility_001, TestSize.Level1)
264 {
265 ServiceExtensionContext serviceExtensionContextTest;
266 Want want;
267 int32_t accountId = 1;
268 sptr<AbilityConnectCallback> connectCallback;
269 ErrCode result = serviceExtensionContextTest.DisconnectAbility(want, connectCallback, accountId);
270 GTEST_LOG_(INFO) <<result;
271 EXPECT_EQ(AAFwk::ERR_INVALID_CALLER, result);
272 }
273
274 /*
275 * Feature: ServiceExtensionContext
276 * Function: startAbility
277 * SubFunction: NA
278 * FunctionPoints: ServiceExtensionContextTest TerminateAbility
279 * EnvConditions: NA
280 * CaseDescription: Verify startAbility
281 */
282 HWTEST_F(ServiceExtensionContextTest, service_extension_context_TerminateAbility_001, TestSize.Level1)
283 {
284 ServiceExtensionContext serviceExtensionContextTest;
285 ErrCode result = serviceExtensionContextTest.TerminateAbility();
286 EXPECT_EQ(ERR_INVALID_VALUE, result);
287 }
288
289 /*
290 * Feature: ServiceExtensionContext
291 * Function: startAbility
292 * SubFunction: NA
293 * FunctionPoints: ServiceExtensionContextTest RequestModalUIExtension
294 * EnvConditions: NA
295 * CaseDescription: Verify startAbility
296 */
297 HWTEST_F(ServiceExtensionContextTest, service_extension_context_RequestModalUIExtension_001, TestSize.Level1)
298 {
299 ServiceExtensionContext serviceExtensionContextTest;
300 Want want;
301 ErrCode result = serviceExtensionContextTest.RequestModalUIExtension(want);
302 EXPECT_EQ(serviceExtensionContextTest.localCallContainer_, nullptr);
303 GTEST_LOG_(INFO) <<result;
304 }
305
306 /*
307 * Feature: ServiceExtensionContext
308 * Function: startAbility
309 * SubFunction: NA
310 * FunctionPoints: ServiceExtensionContextTest GetAbilityInfoType
311 * EnvConditions: NA
312 * CaseDescription: Verify startAbility
313 */
314 HWTEST_F(ServiceExtensionContextTest, service_extension_context_GetAbilityInfoType_001, TestSize.Level1)
315 {
316 ServiceExtensionContext serviceExtensionContextTest;
317 EXPECT_EQ(AppExecFwk::AbilityType::UNKNOWN, serviceExtensionContextTest.GetAbilityInfoType());
318 }
319
320 /**
321 * @tc.number: service_extension_context_startAbility_003
322 * @tc.name: StartAbility
323 * @tc.desc: Start ability success
324 */
325 HWTEST_F(ServiceExtensionContextTest, service_extension_context_startAbility_003, TestSize.Level1)
326 {
327 GTEST_LOG_(INFO) << "service_extension_context_startAbility_003 start";
328 ServiceExtensionContext serviceExtensionContextTest;
329 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
330 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
331
332 AAFwk::Want want;
333 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
334 want.SetElement(element);
335 auto ret = serviceExtensionContextTest.StartAbility(want);
336 EXPECT_EQ(ret, ERR_OK);
337 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
338 GTEST_LOG_(INFO) << "service_extension_context_startAbility_003 end";
339 }
340
341 /**
342 * @tc.number: service_extension_context_StartAbilityWithAccount_003
343 * @tc.name: StartAbility
344 * @tc.desc: Start ability with Account success
345 */
346 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartAbilityWithAccount_003, TestSize.Level1)
347 {
348 GTEST_LOG_(INFO) << "service_extension_context_StartAbilityWithAccount_003 start";
349 ServiceExtensionContext serviceExtensionContextTest;
350 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
351 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
352
353 AAFwk::Want want;
354 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
355 want.SetElement(element);
356 int32_t accountId = 1;
357
358 auto ret = serviceExtensionContextTest.StartAbilityWithAccount(want, accountId);
359 EXPECT_EQ(ret, ERR_OK);
360 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
361 GTEST_LOG_(INFO) << "service_extension_context_StartAbilityWithAccount_003 end";
362 }
363
364 /**
365 * @tc.number: service_extension_context_StartServiceExtensionAbility_002
366 * @tc.name: StartAbility
367 * @tc.desc: Start service extension ability success
368 */
369 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StartServiceExtensionAbility_002, TestSize.Level1)
370 {
371 GTEST_LOG_(INFO) << "service_extension_context_StartServiceExtensionAbility_002 start";
372 ServiceExtensionContext serviceExtensionContextTest;
373 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
374 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
375
376 AAFwk::Want want;
377 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
378 want.SetElement(element);
379 int32_t accountId = 1;
380
381 auto ret = serviceExtensionContextTest.StartServiceExtensionAbility(want, accountId);
382 EXPECT_EQ(ret, ERR_OK);
383 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
384 GTEST_LOG_(INFO) << "service_extension_context_StartServiceExtensionAbility_002 end";
385 }
386
387 /**
388 * @tc.number: service_extension_context_StopServiceExtensionAbility_002
389 * @tc.name: StopServiceExtensionAbility
390 * @tc.desc: Stop service extension ability success
391 */
392 HWTEST_F(ServiceExtensionContextTest, service_extension_context_StopServiceExtensionAbility_002, TestSize.Level1)
393 {
394 GTEST_LOG_(INFO) << "service_extension_context_StopServiceExtensionAbility_002 start";
395 ServiceExtensionContext serviceExtensionContextTest;
396 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
397 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
398
399 AAFwk::Want want;
400 AppExecFwk::ElementName element("device", "com.ix.hiMusic", "MusicAbility");
401 want.SetElement(element);
402 int32_t accountId = 1;
403
404 auto ret = serviceExtensionContextTest.StopServiceExtensionAbility(want, accountId);
405 EXPECT_EQ(ret, ERR_OK);
406 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
407 GTEST_LOG_(INFO) << "service_extension_context_StopServiceExtensionAbility_002 end";
408 }
409
410 /**
411 * @tc.number: service_extension_context_TerminateAbility_002
412 * @tc.name: TerminateAbility
413 * @tc.desc: Terminate ability success
414 */
415 HWTEST_F(ServiceExtensionContextTest, service_extension_context_TerminateAbility_002, TestSize.Level1)
416 {
417 GTEST_LOG_(INFO) << "service_extension_context_TerminateAbility_002 start";
418 ServiceExtensionContext serviceExtensionContextTest;
419 sptr<AAFwk::AbilityManagerStubTestMock> mock = new AAFwk::AbilityManagerStubTestMock();
420 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = mock;
421
422 auto ret = serviceExtensionContextTest.TerminateAbility();
423 EXPECT_EQ(ret, ERR_OK);
424 AAFwk::AbilityManagerClient::GetInstance()->proxy_ = nullptr;
425 GTEST_LOG_(INFO) << "service_extension_context_TerminateAbility_002 end";
426 }
427
428 /**
429 * @tc.number: service_extension_context_ClearFailedCallConnection_001
430 * @tc.name: ClearFailedCallConnection
431 * @tc.desc: clear failed call connection execute normally
432 */
433 HWTEST_F(ServiceExtensionContextTest, service_extension_context_ClearFailedCallConnection_001, TestSize.Level1)
434 {
435 GTEST_LOG_(INFO) << "service_extension_context_ClearFailedCallConnection_001 start";
436 ServiceExtensionContext serviceExtensionContextTest;
437 serviceExtensionContextTest.ClearFailedCallConnection(nullptr);
438 EXPECT_EQ(serviceExtensionContextTest.localCallContainer_, nullptr);
439 serviceExtensionContextTest.localCallContainer_ = std::make_shared<LocalCallContainer>();
440 serviceExtensionContextTest.ClearFailedCallConnection(nullptr);
441 EXPECT_NE(serviceExtensionContextTest.localCallContainer_, nullptr);
442 GTEST_LOG_(INFO) << "service_extension_context_ClearFailedCallConnection_001 end";
443 }
444 }
445 }
446