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  */
HWTEST_F(AbilityExtensionTest, SetCallingInfo_0100, TestSize.Level1)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  */
HWTEST_F(AbilityExtensionTest, GetCallingInfo_0100, TestSize.Level1)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  */
HWTEST_F(AbilityExtensionTest, SetLastRequestWant_0100, TestSize.Level1)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_NE(extension.lastRequestWant_, nullptr);
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  */
HWTEST_F(AbilityExtensionTest, SetLaunchWant_0100, TestSize.Level1)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_NE(extension.launchWant_, nullptr);
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  */
HWTEST_F(AbilityExtensionTest, Init_0100, TestSize.Level1)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_EQ(extension.abilityInfo_, nullptr);
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  */
HWTEST_F(AbilityExtensionTest, Init_0200, TestSize.Level1)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     auto record = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr, nullptr, 0);
186     std::shared_ptr<AppExecFwk::OHOSApplication> application = nullptr;
187     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
188     sptr<IRemoteObject> token = nullptr;
189 
190     Extension extension;
191     extension.Init(record, application, handler, token);
192     EXPECT_EQ(extension.abilityInfo_, nullptr);
193 
194     TAG_LOGI(AAFwkTag::TEST, "Init end");
195 }
196 
197 /**
198  * @tc.name: Init_0300
199  * @tc.desc: basic function test.
200  * @tc.type: FUNC
201  * @tc.require: issueI5TR35
202  */
HWTEST_F(AbilityExtensionTest, Init_0300, TestSize.Level1)203 HWTEST_F(AbilityExtensionTest, Init_0300, TestSize.Level1)
204 {
205     TAG_LOGI(AAFwkTag::TEST, "Init start");
206 
207     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
208     auto record = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr, nullptr, 0);
209     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
210     std::shared_ptr<AppExecFwk::AbilityHandler> handler = nullptr;
211     sptr<IRemoteObject> token = nullptr;
212 
213     Extension extension;
214     extension.Init(record, application, handler, token);
215     EXPECT_EQ(extension.abilityInfo_, nullptr);
216 
217     TAG_LOGI(AAFwkTag::TEST, "Init end");
218 }
219 
220 /**
221  * @tc.name: Init_0400
222  * @tc.desc: basic function test.
223  * @tc.type: FUNC
224  * @tc.require: issueI5TR35
225  */
HWTEST_F(AbilityExtensionTest, Init_0400, TestSize.Level1)226 HWTEST_F(AbilityExtensionTest, Init_0400, TestSize.Level1)
227 {
228     TAG_LOGI(AAFwkTag::TEST, "Init start");
229 
230     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
231     auto record = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr, nullptr, 0);
232     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
233     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
234     sptr<IRemoteObject> token = nullptr;
235 
236     Extension extension;
237     extension.Init(record, application, handler, token);
238     EXPECT_EQ(extension.abilityInfo_, nullptr);
239 
240     TAG_LOGI(AAFwkTag::TEST, "Init end");
241 }
242 
243 /**
244  * @tc.name: Init_0500
245  * @tc.desc: basic function test.
246  * @tc.type: FUNC
247  * @tc.require: issueI5TR35
248  */
HWTEST_F(AbilityExtensionTest, Init_0500, TestSize.Level1)249 HWTEST_F(AbilityExtensionTest, Init_0500, TestSize.Level1)
250 {
251     TAG_LOGI(AAFwkTag::TEST, "Init start");
252 
253     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
254     auto record = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr, nullptr, 0);
255     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
256     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
257     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
258 
259     Extension extension;
260     extension.Init(record, application, handler, token);
261     EXPECT_NE(extension.abilityInfo_, nullptr);
262 
263     TAG_LOGI(AAFwkTag::TEST, "Init end");
264 }
265 
266 /**
267  * @tc.name: OnStart_0100
268  * @tc.desc: basic function test.
269  * @tc.type: FUNC
270  * @tc.require: issueI5TR35
271  */
HWTEST_F(AbilityExtensionTest, OnStart_0100, TestSize.Level1)272 HWTEST_F(AbilityExtensionTest, OnStart_0100, TestSize.Level1)
273 {
274     TAG_LOGI(AAFwkTag::TEST, "OnStart start");
275 
276     Extension extension;
277     // Init extension
278     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
279     auto record = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr, nullptr, 0);
280     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
281     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
282     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
283     extension.Init(record, application, handler, token);
284 
285     std::string deviceId = "0";
286     std::string bundleName = "ohos.test.bundle";
287     std::string abilityName = "TestAbilityOnConnect_0100";
288     std::string moduleName = "OnStart_0100";
289     ElementName elementName;
290     elementName.SetDeviceID(deviceId);
291     elementName.SetBundleName(bundleName);
292     elementName.SetAbilityName(abilityName);
293     elementName.SetModuleName(moduleName);
294     Want want;
295     want.SetElement(elementName);
296 
297     // Test
298     extension.OnStart(want);
299     EXPECT_NE(extension.abilityInfo_, nullptr);
300 
301     TAG_LOGI(AAFwkTag::TEST, "OnStart end");
302 }
303 
304 /**
305  * @tc.name: OnStop_0100
306  * @tc.desc: basic function test.
307  * @tc.type: FUNC
308  * @tc.require: issueI5TR35
309  */
HWTEST_F(AbilityExtensionTest, OnStop_0100, TestSize.Level1)310 HWTEST_F(AbilityExtensionTest, OnStop_0100, TestSize.Level1)
311 {
312     TAG_LOGI(AAFwkTag::TEST, "OnStop start");
313 
314     Extension extension;
315     // Init extension
316     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
317     auto record = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr, nullptr, 0);
318     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
319     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
320     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
321     extension.Init(record, application, handler, token);
322 
323     // Test
324     extension.OnStop();
325     EXPECT_NE(extension.abilityInfo_, nullptr);
326 
327     TAG_LOGI(AAFwkTag::TEST, "OnStop end");
328 }
329 
330 /**
331  * @tc.name: OnConnect_0100
332  * @tc.desc: basic function test.
333  * @tc.type: FUNC
334  * @tc.require: issueI5TR35
335  */
HWTEST_F(AbilityExtensionTest, OnConnect_0100, TestSize.Level1)336 HWTEST_F(AbilityExtensionTest, OnConnect_0100, TestSize.Level1)
337 {
338     TAG_LOGI(AAFwkTag::TEST, "OnConnect start");
339 
340     Extension extension;
341     // Init extension
342     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
343     auto record = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr, nullptr, 0);
344     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
345     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
346     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
347     extension.Init(record, application, handler, token);
348 
349     std::string deviceId;
350     std::string bundleName = "ohos.test.bundle";
351     std::string abilityName = "TestAbilityOnConnect_0100";
352     std::string moduleName = "OnConnect_0100";
353     ElementName elementName;
354     elementName.SetDeviceID(deviceId);
355     elementName.SetBundleName(bundleName);
356     elementName.SetAbilityName(abilityName);
357     elementName.SetModuleName(moduleName);
358     Want want;
359     want.SetElement(elementName);
360 
361     // Test
362     auto result = extension.OnConnect(want);
363     EXPECT_EQ(result, nullptr);
364 
365     TAG_LOGI(AAFwkTag::TEST, "OnConnect end");
366 }
367 
368 /**
369  * @tc.name: OnDisconnect_0100
370  * @tc.desc: basic function test.
371  * @tc.type: FUNC
372  * @tc.require: issueI5TR35
373  */
HWTEST_F(AbilityExtensionTest, OnDisconnect_0100, TestSize.Level1)374 HWTEST_F(AbilityExtensionTest, OnDisconnect_0100, TestSize.Level1)
375 {
376     TAG_LOGI(AAFwkTag::TEST, "OnDisconnect start");
377 
378     Extension extension;
379     // Init extension
380     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
381     auto record = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr, nullptr, 0);
382     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
383     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
384     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
385     extension.Init(record, application, handler, token);
386 
387     std::string deviceId;
388     std::string bundleName = "ohos.test.bundle";
389     std::string abilityName = "TestAbility";
390     std::string moduleName = "entry";
391     ElementName elementName;
392     elementName.SetDeviceID(deviceId);
393     elementName.SetBundleName(bundleName);
394     elementName.SetAbilityName(abilityName);
395     elementName.SetModuleName(moduleName);
396     Want want;
397     want.SetElement(elementName);
398 
399     // Test
400     extension.OnDisconnect(want);
401     EXPECT_NE(extension.abilityInfo_, nullptr);
402 
403     TAG_LOGI(AAFwkTag::TEST, "OnDisconnect end");
404 }
405 
406 /**
407  * @tc.name: OnDisconnect_0200
408  * @tc.desc: basic function test.
409  * @tc.type: FUNC
410  * @tc.require: issueI5TR35
411  */
HWTEST_F(AbilityExtensionTest, OnDisconnect_0200, TestSize.Level1)412 HWTEST_F(AbilityExtensionTest, OnDisconnect_0200, TestSize.Level1)
413 {
414     TAG_LOGI(AAFwkTag::TEST, "OnDisconnect start");
415 
416     Extension extension;
417     // Init extension
418     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
419     auto record = std::make_shared<AppExecFwk::AbilityLocalRecord>(info, nullptr, nullptr, 0);
420     std::shared_ptr<AppExecFwk::OHOSApplication> application = std::make_shared<AppExecFwk::OHOSApplication>();
421     std::shared_ptr<AppExecFwk::AbilityHandler> handler = std::make_shared<AppExecFwk::AbilityHandler>(nullptr);
422     sptr<IRemoteObject> token = new AppExecFwk::MockAbilityToken();
423     extension.Init(record, application, handler, token);
424 
425     std::string deviceId;
426     std::string bundleName = "ohos.test.bundle";
427     std::string abilityName = "TestAbility";
428     std::string moduleName = "entry";
429     ElementName elementName;
430     elementName.SetDeviceID(deviceId);
431     elementName.SetBundleName(bundleName);
432     elementName.SetAbilityName(abilityName);
433     elementName.SetModuleName(moduleName);
434     Want want;
435     want.SetElement(elementName);
436     bool isAsyncCallback = true;
437     AppExecFwk::AbilityTransactionCallbackInfo callbackInfo;
438 
439     // Test
440     extension.OnDisconnect(want, &callbackInfo, isAsyncCallback);
441     EXPECT_EQ(isAsyncCallback, false);
442 
443     TAG_LOGI(AAFwkTag::TEST, "OnDisconnect end");
444 }
445 
446 /**
447  * @tc.name: OnCommand_0100
448  * @tc.desc: basic function test.
449  * @tc.type: FUNC
450  * @tc.require: issueI5TR35
451  */
HWTEST_F(AbilityExtensionTest, OnCommand_0100, TestSize.Level1)452 HWTEST_F(AbilityExtensionTest, OnCommand_0100, TestSize.Level1)
453 {
454     TAG_LOGI(AAFwkTag::TEST, "OnCommand start");
455 
456     std::string deviceId;
457     std::string bundleName = "ohos.test.bundle";
458     std::string abilityName = "TestAbility";
459     std::string moduleName = "entry";
460     ElementName elementName;
461     elementName.SetDeviceID(deviceId);
462     elementName.SetBundleName(bundleName);
463     elementName.SetAbilityName(abilityName);
464     elementName.SetModuleName(moduleName);
465     Want want;
466     want.SetElement(elementName);
467     bool restart = true;
468     int startId = 0;
469 
470     Extension extension;
471     extension.OnCommand(want, restart, startId);
472     EXPECT_EQ(extension.abilityInfo_, nullptr);
473 
474     TAG_LOGI(AAFwkTag::TEST, "OnCommand end");
475 }
476 
477 /**
478  * @tc.name: OnCommand_0200
479  * @tc.desc: basic function test.
480  * @tc.type: FUNC
481  * @tc.require: issueI5TR35
482  */
HWTEST_F(AbilityExtensionTest, OnCommand_0200, TestSize.Level1)483 HWTEST_F(AbilityExtensionTest, OnCommand_0200, TestSize.Level1)
484 {
485     TAG_LOGI(AAFwkTag::TEST, "OnCommand start");
486 
487     std::string deviceId;
488     std::string bundleName = "ohos.test.bundle";
489     std::string abilityName = "TestAbility";
490     std::string moduleName = "entry";
491     ElementName elementName;
492     elementName.SetDeviceID(deviceId);
493     elementName.SetBundleName(bundleName);
494     elementName.SetAbilityName(abilityName);
495     elementName.SetModuleName(moduleName);
496     Want want;
497     want.SetElement(elementName);
498     bool restart = false;
499     int startId = 0;
500 
501     Extension extension;
502     extension.OnCommand(want, restart, startId);
503     EXPECT_EQ(extension.abilityInfo_, nullptr);
504 
505     TAG_LOGI(AAFwkTag::TEST, "OnCommand end");
506 }
507 
508 /**
509  * @tc.name: OnConfigurationUpdated_0100
510  * @tc.desc: basic function test.
511  * @tc.type: FUNC
512  * @tc.require: issueI5TR35
513  */
HWTEST_F(AbilityExtensionTest, OnConfigurationUpdated_0100, TestSize.Level1)514 HWTEST_F(AbilityExtensionTest, OnConfigurationUpdated_0100, TestSize.Level1)
515 {
516     TAG_LOGI(AAFwkTag::TEST, "OnConfigurationUpdated start");
517 
518     AppExecFwk::Configuration configuration;
519 
520     Extension extension;
521     extension.OnConfigurationUpdated(configuration);
522     EXPECT_EQ(extension.abilityInfo_, nullptr);
523 
524     TAG_LOGI(AAFwkTag::TEST, "OnConfigurationUpdated end");
525 }
526 
527 /**
528  * @tc.name: OnMemoryLevel_0100
529  * @tc.desc: basic function test.
530  * @tc.type: FUNC
531  * @tc.require: issueI5TR35
532  */
HWTEST_F(AbilityExtensionTest, OnMemoryLevel_0100, TestSize.Level1)533 HWTEST_F(AbilityExtensionTest, OnMemoryLevel_0100, TestSize.Level1)
534 {
535     TAG_LOGI(AAFwkTag::TEST, "OnMemoryLevel start");
536 
537     Extension extension;
538     int level = 0;
539     extension.OnMemoryLevel(level);
540     EXPECT_EQ(extension.abilityInfo_, nullptr);
541 
542     TAG_LOGI(AAFwkTag::TEST, "OnMemoryLevel end");
543 }
544 
545 /**
546  * @tc.name: Dump_0100
547  * @tc.desc: basic function test.
548  * @tc.type: FUNC
549  * @tc.require: issueI5TR35
550  */
HWTEST_F(AbilityExtensionTest, Dump_0100, TestSize.Level1)551 HWTEST_F(AbilityExtensionTest, Dump_0100, TestSize.Level1)
552 {
553     TAG_LOGI(AAFwkTag::TEST, "Dump start");
554 
555     std::vector<std::string> params;
556     params.push_back("params1");
557     params.push_back("params2");
558     params.push_back("params3");
559     std::vector<std::string> info;
560     info.push_back("info1");
561     info.push_back("info2");
562     info.push_back("info3");
563 
564     Extension extension;
565     extension.Dump(params, info);
566     EXPECT_EQ(extension.abilityInfo_, nullptr);
567 
568     TAG_LOGI(AAFwkTag::TEST, "Dump end");
569 }
570 
571 } // namespace AbilityRuntime
572 } // namespace OHOS