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 #define protected public
20 #include "extension.h"
21 #undef private
22 #undef protected
23 
24 #include "ability_handler.h"
25 #include "ability_transaction_callback_info.h"
26 #include "configuration.h"
27 #include "hilog_tag_wrapper.h"
28 #include "iremote_object.h"
29 #include "mock_ability_token.h"
30 #include "ohos_application.h"
31 #include "want.h"
32 
33 using namespace testing::ext;
34 using OHOS::AppExecFwk::ElementName;
35 
36 namespace OHOS {
37 namespace AbilityRuntime {
38 class AbilityExtensionTest : public testing::Test {
39 public:
40     static void SetUpTestCase();
41     static void TearDownTestCase();
42     void SetUp() override;
43     void TearDown() override;
44 };
45 
SetUpTestCase(void)46 void AbilityExtensionTest::SetUpTestCase(void)
47 {}
48 
TearDownTestCase(void)49 void AbilityExtensionTest::TearDownTestCase(void)
50 {}
51 
SetUp()52 void AbilityExtensionTest::SetUp()
53 {}
54 
TearDown()55 void AbilityExtensionTest::TearDown()
56 {}
57 
58 /**
59  * @tc.name: SetCallingInfo_0100
60  * @tc.desc: basic function test.
61  * @tc.type: FUNC
62  * @tc.require: issueI5TR35
63  */
64 HWTEST_F(AbilityExtensionTest, SetCallingInfo_0100, TestSize.Level1)
65 {
66     TAG_LOGI(AAFwkTag::TEST, "SetCallingInfo start");
67 
68     Extension extension;
69     CallingInfo callingInfo;
70     extension.SetCallingInfo(callingInfo);
71     EXPECT_NE(extension.callingInfo_, nullptr);
72 
73     TAG_LOGI(AAFwkTag::TEST, "SetCallingInfo end");
74 }
75 
76 /**
77  * @tc.name: GetCallingInfo_0100
78  * @tc.desc: basic function test.
79  * @tc.type: FUNC
80  * @tc.require: issueI5TR35
81  */
82 HWTEST_F(AbilityExtensionTest, GetCallingInfo_0100, TestSize.Level1)
83 {
84     TAG_LOGI(AAFwkTag::TEST, "GetCallingInfo start");
85 
86     Extension extension;
87     CallingInfo callingInfo;
88     extension.SetCallingInfo(callingInfo);
89     auto result = extension.GetCallingInfo();
90     EXPECT_NE(result, nullptr);
91 
92     TAG_LOGI(AAFwkTag::TEST, "GetCallingInfo end");
93 }
94 
95 /**
96  * @tc.name: SetLastRequestWant_0100
97  * @tc.desc: basic function test.
98  * @tc.type: FUNC
99  * @tc.require: issueI5TR35
100  */
101 HWTEST_F(AbilityExtensionTest, SetLastRequestWant_0100, TestSize.Level1)
102 {
103     TAG_LOGI(AAFwkTag::TEST, "SetLastRequestWant start");
104 
105     Extension extension;
106     std::string deviceId;
107     std::string bundleName = "ohos.test.bundle";
108     std::string abilityName = "TestAbility";
109     std::string moduleName = "entry";
110     ElementName elementName;
111     elementName.SetDeviceID(deviceId);
112     elementName.SetBundleName(bundleName);
113     elementName.SetAbilityName(abilityName);
114     elementName.SetModuleName(moduleName);
115     Want want;
116     want.SetElement(elementName);
117     extension.SetLastRequestWant(want);
118     EXPECT_TRUE(true);
119 
120     TAG_LOGI(AAFwkTag::TEST, "SetLastRequestWant end");
121 }
122 
123 /**
124  * @tc.name: SetLaunchWant_0100
125  * @tc.desc: basic function test.
126  * @tc.type: FUNC
127  * @tc.require: issueI5TR35
128  */
129 HWTEST_F(AbilityExtensionTest, SetLaunchWant_0100, TestSize.Level1)
130 {
131     TAG_LOGI(AAFwkTag::TEST, "SetLaunchWant start");
132 
133     std::string deviceId;
134     std::string bundleName = "ohos.test.bundle";
135     std::string abilityName = "TestAbility";
136     std::string moduleName = "entry";
137     ElementName elementName;
138     elementName.SetDeviceID(deviceId);
139     elementName.SetBundleName(bundleName);
140     elementName.SetAbilityName(abilityName);
141     elementName.SetModuleName(moduleName);
142     Want want;
143     want.SetElement(elementName);
144 
145     Extension extension;
146     extension.SetLaunchWant(want);
147     EXPECT_TRUE(true);
148 
149     TAG_LOGI(AAFwkTag::TEST, "SetLaunchWant end");
150 }
151 
152 /**
153  * @tc.name: Init_0100
154  * @tc.desc: basic function test.
155  * @tc.type: FUNC
156  * @tc.require: issueI5TR35
157  */
158 HWTEST_F(AbilityExtensionTest, Init_0100, TestSize.Level1)
159 {
160     TAG_LOGI(AAFwkTag::TEST, "Init start");
161 
162     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record = nullptr;
163     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
164     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
165     sptr<IRemoteObject> token = nullptr;
166 
167     Extension extension;
168     extension.Init(record, application, handler, token);
169     EXPECT_TRUE(true);
170 
171     TAG_LOGI(AAFwkTag::TEST, "Init end");
172 }
173 
174 /**
175  * @tc.name: Init_0200
176  * @tc.desc: basic function test.
177  * @tc.type: FUNC
178  * @tc.require: issueI5TR35
179  */
180 HWTEST_F(AbilityExtensionTest, Init_0200, TestSize.Level1)
181 {
182     TAG_LOGI(AAFwkTag::TEST, "Init start");
183 
184     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
185     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record =
186         std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr);
187     std::shared_ptr<AppExecFwk::OHOSApplication> application = nullptr;
188     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
189     sptr<IRemoteObject> token = nullptr;
190 
191     Extension extension;
192     extension.Init(record, application, handler, token);
193     EXPECT_TRUE(true);
194 
195     TAG_LOGI(AAFwkTag::TEST, "Init end");
196 }
197 
198 /**
199  * @tc.name: Init_0300
200  * @tc.desc: basic function test.
201  * @tc.type: FUNC
202  * @tc.require: issueI5TR35
203  */
204 HWTEST_F(AbilityExtensionTest, Init_0300, TestSize.Level1)
205 {
206     TAG_LOGI(AAFwkTag::TEST, "Init start");
207 
208     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
209     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record =
210         std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr);
211     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
212     std::shared_ptr<AppExecFwk::AbilityHandler> handler = nullptr;
213     sptr<IRemoteObject> token = nullptr;
214 
215     Extension extension;
216     extension.Init(record, application, handler, token);
217     EXPECT_TRUE(true);
218 
219     TAG_LOGI(AAFwkTag::TEST, "Init end");
220 }
221 
222 /**
223  * @tc.name: Init_0400
224  * @tc.desc: basic function test.
225  * @tc.type: FUNC
226  * @tc.require: issueI5TR35
227  */
228 HWTEST_F(AbilityExtensionTest, Init_0400, TestSize.Level1)
229 {
230     TAG_LOGI(AAFwkTag::TEST, "Init start");
231 
232     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
233     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record =
234         std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr);
235     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
236     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
237     sptr<IRemoteObject> token = nullptr;
238 
239     Extension extension;
240     extension.Init(record, application, handler, token);
241     EXPECT_TRUE(true);
242 
243     TAG_LOGI(AAFwkTag::TEST, "Init end");
244 }
245 
246 /**
247  * @tc.name: Init_0500
248  * @tc.desc: basic function test.
249  * @tc.type: FUNC
250  * @tc.require: issueI5TR35
251  */
252 HWTEST_F(AbilityExtensionTest, Init_0500, TestSize.Level1)
253 {
254     TAG_LOGI(AAFwkTag::TEST, "Init start");
255 
256     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
257     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record =
258         std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr);
259     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
260     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
261     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
262 
263     Extension extension;
264     extension.Init(record, application, handler, token);
265     EXPECT_TRUE(true);
266 
267     TAG_LOGI(AAFwkTag::TEST, "Init end");
268 }
269 
270 /**
271  * @tc.name: OnStart_0100
272  * @tc.desc: basic function test.
273  * @tc.type: FUNC
274  * @tc.require: issueI5TR35
275  */
276 HWTEST_F(AbilityExtensionTest, OnStart_0100, TestSize.Level1)
277 {
278     TAG_LOGI(AAFwkTag::TEST, "OnStart start");
279 
280     Extension extension;
281     // Init extension
282     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
283     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record =
284         std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr);
285     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
286     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
287     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
288     extension.Init(record, application, handler, token);
289 
290     std::string deviceId = "0";
291     std::string bundleName = "ohos.test.bundle";
292     std::string abilityName = "TestAbilityOnConnect_0100";
293     std::string moduleName = "OnStart_0100";
294     ElementName elementName;
295     elementName.SetDeviceID(deviceId);
296     elementName.SetBundleName(bundleName);
297     elementName.SetAbilityName(abilityName);
298     elementName.SetModuleName(moduleName);
299     Want want;
300     want.SetElement(elementName);
301 
302     // Test
303     extension.OnStart(want);
304     EXPECT_TRUE(true);
305 
306     TAG_LOGI(AAFwkTag::TEST, "OnStart end");
307 }
308 
309 /**
310  * @tc.name: OnStop_0100
311  * @tc.desc: basic function test.
312  * @tc.type: FUNC
313  * @tc.require: issueI5TR35
314  */
315 HWTEST_F(AbilityExtensionTest, OnStop_0100, TestSize.Level1)
316 {
317     TAG_LOGI(AAFwkTag::TEST, "OnStop start");
318 
319     Extension extension;
320     // Init extension
321     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
322     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record =
323         std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr);
324     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
325     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
326     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
327     extension.Init(record, application, handler, token);
328 
329     // Test
330     extension.OnStop();
331     EXPECT_TRUE(true);
332 
333     TAG_LOGI(AAFwkTag::TEST, "OnStop end");
334 }
335 
336 /**
337  * @tc.name: OnConnect_0100
338  * @tc.desc: basic function test.
339  * @tc.type: FUNC
340  * @tc.require: issueI5TR35
341  */
342 HWTEST_F(AbilityExtensionTest, OnConnect_0100, TestSize.Level1)
343 {
344     TAG_LOGI(AAFwkTag::TEST, "OnConnect start");
345 
346     Extension extension;
347     // Init extension
348     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
349     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record =
350         std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr);
351     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
352     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
353     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
354     extension.Init(record, application, handler, token);
355 
356     std::string deviceId;
357     std::string bundleName = "ohos.test.bundle";
358     std::string abilityName = "TestAbilityOnConnect_0100";
359     std::string moduleName = "OnConnect_0100";
360     ElementName elementName;
361     elementName.SetDeviceID(deviceId);
362     elementName.SetBundleName(bundleName);
363     elementName.SetAbilityName(abilityName);
364     elementName.SetModuleName(moduleName);
365     Want want;
366     want.SetElement(elementName);
367 
368     // Test
369     extension.OnConnect(want);
370     EXPECT_TRUE(true);
371 
372     TAG_LOGI(AAFwkTag::TEST, "OnConnect end");
373 }
374 
375 /**
376  * @tc.name: OnDisconnect_0100
377  * @tc.desc: basic function test.
378  * @tc.type: FUNC
379  * @tc.require: issueI5TR35
380  */
381 HWTEST_F(AbilityExtensionTest, OnDisconnect_0100, TestSize.Level1)
382 {
383     TAG_LOGI(AAFwkTag::TEST, "OnDisconnect start");
384 
385     Extension extension;
386     // Init extension
387     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
388     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record =
389         std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr);
390     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
391     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
392     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
393     extension.Init(record, application, handler, token);
394 
395     std::string deviceId;
396     std::string bundleName = "ohos.test.bundle";
397     std::string abilityName = "TestAbility";
398     std::string moduleName = "entry";
399     ElementName elementName;
400     elementName.SetDeviceID(deviceId);
401     elementName.SetBundleName(bundleName);
402     elementName.SetAbilityName(abilityName);
403     elementName.SetModuleName(moduleName);
404     Want want;
405     want.SetElement(elementName);
406 
407     // Test
408     extension.OnDisconnect(want);
409     EXPECT_TRUE(true);
410 
411     TAG_LOGI(AAFwkTag::TEST, "OnDisconnect end");
412 }
413 
414 /**
415  * @tc.name: OnDisconnect_0200
416  * @tc.desc: basic function test.
417  * @tc.type: FUNC
418  * @tc.require: issueI5TR35
419  */
420 HWTEST_F(AbilityExtensionTest, OnDisconnect_0200, TestSize.Level1)
421 {
422     TAG_LOGI(AAFwkTag::TEST, "OnDisconnect start");
423 
424     Extension extension;
425     // Init extension
426     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
427     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record =
428         std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr);
429     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
430     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
431     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
432     extension.Init(record, application, handler, token);
433 
434     std::string deviceId;
435     std::string bundleName = "ohos.test.bundle";
436     std::string abilityName = "TestAbility";
437     std::string moduleName = "entry";
438     ElementName elementName;
439     elementName.SetDeviceID(deviceId);
440     elementName.SetBundleName(bundleName);
441     elementName.SetAbilityName(abilityName);
442     elementName.SetModuleName(moduleName);
443     Want want;
444     want.SetElement(elementName);
445     bool isAsyncCallback = true;
446     AppExecFwk::AbilityTransactionCallbackInfo callbackInfo;
447 
448     // Test
449     extension.OnDisconnect(want, &callbackInfo, isAsyncCallback);
450     EXPECT_EQ(isAsyncCallback, false);
451 
452     TAG_LOGI(AAFwkTag::TEST, "OnDisconnect end");
453 }
454 
455 /**
456  * @tc.name: OnCommand_0100
457  * @tc.desc: basic function test.
458  * @tc.type: FUNC
459  * @tc.require: issueI5TR35
460  */
461 HWTEST_F(AbilityExtensionTest, OnCommand_0100, TestSize.Level1)
462 {
463     TAG_LOGI(AAFwkTag::TEST, "OnCommand start");
464 
465     std::string deviceId;
466     std::string bundleName = "ohos.test.bundle";
467     std::string abilityName = "TestAbility";
468     std::string moduleName = "entry";
469     ElementName elementName;
470     elementName.SetDeviceID(deviceId);
471     elementName.SetBundleName(bundleName);
472     elementName.SetAbilityName(abilityName);
473     elementName.SetModuleName(moduleName);
474     Want want;
475     want.SetElement(elementName);
476     bool restart = true;
477     int startId = 0;
478 
479     Extension extension;
480     extension.OnCommand(want, restart, startId);
481     EXPECT_TRUE(true);
482 
483     TAG_LOGI(AAFwkTag::TEST, "OnCommand end");
484 }
485 
486 /**
487  * @tc.name: OnCommand_0200
488  * @tc.desc: basic function test.
489  * @tc.type: FUNC
490  * @tc.require: issueI5TR35
491  */
492 HWTEST_F(AbilityExtensionTest, OnCommand_0200, TestSize.Level1)
493 {
494     TAG_LOGI(AAFwkTag::TEST, "OnCommand start");
495 
496     std::string deviceId;
497     std::string bundleName = "ohos.test.bundle";
498     std::string abilityName = "TestAbility";
499     std::string moduleName = "entry";
500     ElementName elementName;
501     elementName.SetDeviceID(deviceId);
502     elementName.SetBundleName(bundleName);
503     elementName.SetAbilityName(abilityName);
504     elementName.SetModuleName(moduleName);
505     Want want;
506     want.SetElement(elementName);
507     bool restart = false;
508     int startId = 0;
509 
510     Extension extension;
511     extension.OnCommand(want, restart, startId);
512     EXPECT_TRUE(true);
513 
514     TAG_LOGI(AAFwkTag::TEST, "OnCommand end");
515 }
516 
517 /**
518  * @tc.name: OnConfigurationUpdated_0100
519  * @tc.desc: basic function test.
520  * @tc.type: FUNC
521  * @tc.require: issueI5TR35
522  */
523 HWTEST_F(AbilityExtensionTest, OnConfigurationUpdated_0100, TestSize.Level1)
524 {
525     TAG_LOGI(AAFwkTag::TEST, "OnConfigurationUpdated start");
526 
527     AppExecFwk::Configuration configuration;
528 
529     Extension extension;
530     extension.OnConfigurationUpdated(configuration);
531     EXPECT_TRUE(true);
532 
533     TAG_LOGI(AAFwkTag::TEST, "OnConfigurationUpdated end");
534 }
535 
536 /**
537  * @tc.name: OnMemoryLevel_0100
538  * @tc.desc: basic function test.
539  * @tc.type: FUNC
540  * @tc.require: issueI5TR35
541  */
542 HWTEST_F(AbilityExtensionTest, OnMemoryLevel_0100, TestSize.Level1)
543 {
544     TAG_LOGI(AAFwkTag::TEST, "OnMemoryLevel start");
545 
546     Extension extension;
547     int level = 0;
548     extension.OnMemoryLevel(level);
549     EXPECT_TRUE(true);
550 
551     TAG_LOGI(AAFwkTag::TEST, "OnMemoryLevel end");
552 }
553 
554 /**
555  * @tc.name: Dump_0100
556  * @tc.desc: basic function test.
557  * @tc.type: FUNC
558  * @tc.require: issueI5TR35
559  */
560 HWTEST_F(AbilityExtensionTest, Dump_0100, TestSize.Level1)
561 {
562     TAG_LOGI(AAFwkTag::TEST, "Dump start");
563 
564     std::vector<std::string> params;
565     params.push_back("params1");
566     params.push_back("params2");
567     params.push_back("params3");
568     std::vector<std::string> info;
569     info.push_back("info1");
570     info.push_back("info2");
571     info.push_back("info3");
572 
573     Extension extension;
574     extension.Dump(params, info);
575     EXPECT_TRUE(true);
576 
577     TAG_LOGI(AAFwkTag::TEST, "Dump end");
578 }
579 
580 } // namespace AbilityRuntime
581 } // namespace OHOS