1 /*
2  * Copyright (c) 2021-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 #include "ability_manager_client.h"
18 #include "ability_runtime_error_util.h"
19 #include "cancel_listener.h"
20 #include "completed_callback.h"
21 #include "completed_dispatcher.h"
22 #include "context/application_context.h"
23 #include "context_container.h"
24 #include "context_impl.h"
25 #include "element_name.h"
26 #include "event_handler.h"
27 #include "iservice_registry.h"
28 #include "base_types.h"
29 #define private public
30 #define protected public
31 #include "pending_want.h"
32 #undef private
33 #undef protected
34 #include "pending_want_record.h"
35 #include "remote_native_token.h"
36 #include "sa_mgr_client.h"
37 #include "system_ability_definition.h"
38 #include "want.h"
39 #include "wants_info.h"
40 #include "want_params.h"
41 #include "want_receiver_stub.h"
42 #include "want_agent_client.h"
43 #include "want_agent_helper.h"
44 #include "want_sender_info.h"
45 #include "want_sender_stub.h"
46 #include "bool_wrapper.h"
47 #include "zchar_wrapper.h"
48 #include "byte_wrapper.h"
49 #include "double_wrapper.h"
50 #include "float_wrapper.h"
51 #include "int_wrapper.h"
52 #include "long_wrapper.h"
53 #include "short_wrapper.h"
54 #include "string_wrapper.h"
55 #include "array_wrapper.h"
56 #include "hilog_tag_wrapper.h"
57 
58 using namespace testing::ext;
59 using namespace OHOS::AAFwk;
60 using namespace OHOS;
61 using OHOS::AppExecFwk::ElementName;
62 using namespace OHOS::AbilityRuntime;
63 using namespace OHOS::AppExecFwk;
64 using vector_str = std::vector<std::string>;
65 
66 namespace OHOS::AbilityRuntime::WantAgent {
67 namespace {
68     constexpr int32_t NOTEQ = -1;
69 }
70 class PendingWantTest : public testing::Test {
71 public:
PendingWantTest()72     PendingWantTest()
73     {}
~PendingWantTest()74     ~PendingWantTest()
75     {}
76     static void SetUpTestCase(void);
77     static void TearDownTestCase(void);
78     void SetUp();
79     void TearDown();
80     static Want MakeWant(std::string deviceId, std::string abilityName, std::string bundleName);
81 
82     static int callBackCancelListenerConnt;
83 
84     class CancelListenerSon : public CancelListener {
85     public:
86         void OnCancelled(int resultCode) override;
87     };
88 };
89 
90 int PendingWantTest::callBackCancelListenerConnt = 0;
91 
OnCancelled(int resultCode)92 void PendingWantTest::CancelListenerSon::OnCancelled(int resultCode)
93 {
94     callBackCancelListenerConnt++;
95 }
96 
MakeWant(std::string deviceId,std::string abilityName,std::string bundleName)97 Want PendingWantTest::MakeWant(std::string deviceId, std::string abilityName, std::string bundleName)
98 {
99     ElementName element(deviceId, bundleName, abilityName);
100     Want want;
101     want.SetElement(element);
102     return want;
103 }
104 
GetAppContext()105 std::shared_ptr<OHOS::AbilityRuntime::ApplicationContext> GetAppContext()
106 {
107     std::shared_ptr<AbilityRuntime::ApplicationContext> context =
108         AbilityRuntime::ApplicationContext::GetInstance();
109     return context;
110 }
111 
SetUpTestCase(void)112 void PendingWantTest::SetUpTestCase(void)
113 {
114     RemoteNativeToken::SetNativeToken();
115 }
116 
TearDownTestCase(void)117 void PendingWantTest::TearDownTestCase(void)
118 {}
119 
SetUp(void)120 void PendingWantTest::SetUp(void)
121 {}
122 
TearDown(void)123 void PendingWantTest::TearDown(void)
124 {}
125 
126 /*
127  * @tc.number    : PendingWant_0100
128  * @tc.name      : PendingWant Constructors
129  * @tc.desc      : 1.The parameter is nullptr
130  */
131 HWTEST_F(PendingWantTest, PendingWant_0100, Function | MediumTest | Level1)
132 {
133     PendingWant pendingWant(nullptr);
134     EXPECT_EQ(pendingWant.target_, nullptr);
135     EXPECT_EQ(pendingWant.cancelReceiver_, nullptr);
136 }
137 
138 /*
139  * @tc.number    : PendingWant_0200
140  * @tc.name      : PendingWant Constructors
141  * @tc.desc      : 1.The parameter target is not nullptr
142  */
143 HWTEST_F(PendingWantTest, PendingWant_0200, Function | MediumTest | Level1)
144 {
145     sptr<AAFwk::IWantSender> target(new (std::nothrow) PendingWantRecord());
146     PendingWant pendingWant(target);
147     EXPECT_EQ(pendingWant.target_, target);
148     EXPECT_EQ(pendingWant.cancelReceiver_, nullptr);
149 }
150 
151 /*
152  * @tc.number    : PendingWant_0300
153  * @tc.name      : PendingWant GetType
154  * @tc.desc      : 1.Get PendingWant Type (UNKNOWN_TYPE)
155  */
156 HWTEST_F(PendingWantTest, PendingWant_0300, Function | MediumTest | Level1)
157 {
158     sptr<AAFwk::IWantSender> target = nullptr;
159     PendingWant pendingWant(target);
160     EXPECT_EQ(pendingWant.target_, target);
161     EXPECT_EQ(pendingWant.GetType(target), WantAgentConstant::OperationType::UNKNOWN_TYPE);
162 }
163 
164 /*
165  * @tc.number    : PendingWant_0400
166  * @tc.name      : PendingWant GetAbility
167  * @tc.desc      : 1.Get pendingWant (context is nullptr)
168  */
169 HWTEST_F(PendingWantTest, PendingWant_0400, Function | MediumTest | Level1)
170 {
171     int requestCode = 10;
172     std::shared_ptr<Want> want = std::make_shared<Want>();
173     ElementName element("device", "bundleName", "abilityName");
174     want->SetElement(element);
175     unsigned int flags = 1;
176     flags |= FLAG_NO_CREATE;
177     std::shared_ptr<PendingWant> pendingWant = PendingWant::GetAbility(nullptr, requestCode, want, flags);
178     EXPECT_EQ(pendingWant, nullptr);
179 }
180 
181 
182 /*
183  * @tc.number    : PendingWant_0600
184  * @tc.name      : PendingWant GetAbility
185  * @tc.desc      : 1.Get pendingWant (options is not nullptr)
186  */
187 HWTEST_F(PendingWantTest, PendingWant_0600, Function | MediumTest | Level1)
188 {
189     int requestCode = 10;
190     std::shared_ptr<Want> want = std::make_shared<Want>();
191     ElementName element("device", "bundleName", "abilityName");
192     want->SetElement(element);
193     bool value = true;
194     std::string key = "key";
195     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
196     wParams->SetParam(key, Boolean::Box(value));
197     unsigned int flags = 1;
198     flags |= FLAG_ONE_SHOT;
199     std::shared_ptr<PendingWant> pendingWant = nullptr;
200     PendingWant::GetAbility(GetAppContext(), requestCode, want, flags, wParams, pendingWant);
201     EXPECT_NE(pendingWant, nullptr);
202 }
203 
204 /*
205  * @tc.number    : PendingWant_0700
206  * @tc.name      : PendingWant GetAbilities
207  * @tc.desc      : 1.Get pendingWant (context is nullptr)
208  */
209 HWTEST_F(PendingWantTest, PendingWant_0700, Function | MediumTest | Level1)
210 {
211     int requestCode = 10;
212     std::shared_ptr<Want> want = std::make_shared<Want>();
213     ElementName element("device", "bundleName", "abilityName");
214     want->SetElement(element);
215     std::shared_ptr<Want> want2 = std::make_shared<Want>();
216     ElementName element2("device", "bundleName", "abilityName");
217     want2->SetElement(element2);
218     std::vector<std::shared_ptr<Want>> wants;
219     wants.emplace_back(want);
220     wants.emplace_back(want2);
221     unsigned int flags = 1;
222     flags |= FLAG_NO_CREATE;
223     std::shared_ptr<PendingWant> pendingWant = PendingWant::GetAbilities(
224         nullptr, requestCode, wants, flags);
225     EXPECT_EQ(pendingWant, nullptr);
226 }
227 
228 /*
229  * @tc.number    : PendingWant_0800
230  * @tc.name      : PendingWant GetAbilities
231  * @tc.desc      : 1.Get pendingWant (context is not nullptr)
232  */
233 HWTEST_F(PendingWantTest, PendingWant_0800, Function | MediumTest | Level1)
234 {
235     int requestCode = 10;
236     std::shared_ptr<Want> want = std::make_shared<Want>();
237     ElementName element("device", "bundleName", "abilityName");
238     want->SetElement(element);
239     std::shared_ptr<Want> want2 = std::make_shared<Want>();
240     ElementName element2("device", "bundleName", "abilityName");
241     want2->SetElement(element2);
242     std::vector<std::shared_ptr<Want>> wants;
243     wants.emplace_back(want);
244     wants.emplace_back(want2);
245     unsigned int flags = 1;
246     flags |= FLAG_ONE_SHOT;
247     std::shared_ptr<PendingWant> pendingWant = PendingWant::GetAbilities(
248         GetAppContext(), requestCode, wants, flags);
249     EXPECT_NE(pendingWant, nullptr);
250 }
251 
252 /*
253  * @tc.number    : PendingWant_0900
254  * @tc.name      : PendingWant GetAbilities
255  * @tc.desc      : 1.Get pendingWant (options is not nullptr)
256  */
257 HWTEST_F(PendingWantTest, PendingWant_0900, Function | MediumTest | Level1)
258 {
259     int requestCode = 10;
260     std::shared_ptr<Want> want = std::make_shared<Want>();
261     ElementName element("device", "bundleName", "abilityName");
262     want->SetElement(element);
263     std::shared_ptr<Want> want2 = std::make_shared<Want>();
264     ElementName element2("device", "bundleName", "abilityName");
265     want2->SetElement(element2);
266     std::vector<std::shared_ptr<Want>> wants;
267     wants.emplace_back(want);
268     wants.emplace_back(want2);
269     bool value = true;
270     std::string key = "key";
271     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
272     wParams->SetParam(key, Boolean::Box(value));
273     unsigned int flags = 1;
274     flags |= FLAG_ONE_SHOT;
275     std::shared_ptr<PendingWant> pendingWant = nullptr;
276     PendingWant::GetAbilities(GetAppContext(), requestCode, wants, flags, wParams, pendingWant);
277     EXPECT_NE(pendingWant, nullptr);
278 }
279 
280 /*
281  * @tc.number    : PendingWant_1000
282  * @tc.name      : PendingWant GetCommonEventAsUser
283  * @tc.desc      : 1.Get pendingWant (context is nullptr)
284  */
285 HWTEST_F(PendingWantTest, PendingWant_1000, Function | MediumTest | Level1)
286 {
287     int requestCode = 10;
288     std::shared_ptr<Want> want = std::make_shared<Want>();
289     ElementName element("device", "bundleName", "abilityName");
290     want->SetElement(element);
291     unsigned int flags = 1;
292     flags |= FLAG_NO_CREATE;
293     std::shared_ptr<PendingWant> pendingWant = nullptr;
294     PendingWant::GetCommonEventAsUser(nullptr, requestCode, want, flags, 0, pendingWant);
295     EXPECT_EQ(pendingWant, nullptr);
296 }
297 
298 /*
299  * @tc.number    : PendingWant_1100
300  * @tc.name      : PendingWant GetCommonEventAsUser
301  * @tc.desc      : 1.Get pendingWant (context is not nullptr)
302  */
303 HWTEST_F(PendingWantTest, PendingWant_1100, Function | MediumTest | Level1)
304 {
305     int requestCode = 10;
306     std::shared_ptr<Want> want = std::make_shared<Want>();
307     ElementName element("device", "bundleName", "abilityName");
308     want->SetElement(element);
309     unsigned int flags = 1;
310     flags |= FLAG_ONE_SHOT;
311     std::shared_ptr<PendingWant> pendingWant = nullptr;
312     PendingWant::GetCommonEventAsUser(GetAppContext(), requestCode, want, flags, 0, pendingWant);
313     EXPECT_NE(pendingWant, nullptr);
314 }
315 
316 /*
317  * @tc.number    : PendingWant_1200
318  * @tc.name      : PendingWant GetCommonEventAsUser
319  * @tc.desc      : 1.Get pendingWant (want is nullptr)
320  */
321 HWTEST_F(PendingWantTest, PendingWant_1200, Function | MediumTest | Level1)
322 {
323     int requestCode = 10;
324     std::shared_ptr<Want> want;
325     unsigned int flags = 1;
326     flags |= FLAG_ONE_SHOT;
327     std::shared_ptr<PendingWant> pendingWant = nullptr;
328     PendingWant::GetCommonEventAsUser(GetAppContext(), requestCode, want, flags, 0, pendingWant);
329     EXPECT_NE(pendingWant, nullptr);
330 }
331 
332 /*
333  * @tc.number    : PendingWant_1300
334  * @tc.name      : PendingWant GetService
335  * @tc.desc      : 1.Get pendingWant (want is nullptr)
336  */
337 HWTEST_F(PendingWantTest, PendingWant_1300, Function | MediumTest | Level1)
338 {
339     int requestCode = 10;
340     std::shared_ptr<Want> want;
341     unsigned int flags = 1;
342     flags |= FLAG_ONE_SHOT;
343     std::shared_ptr<PendingWant> pendingWant = nullptr;
344     PendingWant::GetService(GetAppContext(), requestCode, want, flags, pendingWant);
345     EXPECT_NE(pendingWant, nullptr);
346 }
347 
348 /*
349  * @tc.number    : PendingWant_1400
350  * @tc.name      : PendingWant GetService
351  * @tc.desc      : 1.Get pendingWant (context is nullptr)
352  */
353 HWTEST_F(PendingWantTest, PendingWant_1400, Function | MediumTest | Level1)
354 {
355     int requestCode = 10;
356     std::shared_ptr<Want> want = std::make_shared<Want>();
357     ElementName element("device", "bundleName", "abilityName");
358     want->SetElement(element);
359     unsigned int flags = 1;
360     flags |= FLAG_ONE_SHOT;
361     std::shared_ptr<PendingWant> pendingWant = nullptr;
362     PendingWant::GetService(nullptr, requestCode, want, flags, pendingWant);
363     EXPECT_EQ(pendingWant, nullptr);
364 }
365 
366 /*
367  * @tc.number    : PendingWant_1500
368  * @tc.name      : PendingWant GetForegroundService
369  * @tc.desc      : 1.Get pendingWant (want is nullptr)
370  */
371 HWTEST_F(PendingWantTest, PendingWant_1500, Function | MediumTest | Level1)
372 {
373     int requestCode = 10;
374     std::shared_ptr<Want> want;
375     unsigned int flags = 1;
376     flags |= FLAG_ONE_SHOT;
377     std::shared_ptr<PendingWant> pendingWant = nullptr;
378     PendingWant::GetForegroundService(GetAppContext(), requestCode, want, flags, pendingWant);
379     EXPECT_NE(pendingWant, nullptr);
380 }
381 
382 /*
383  * @tc.number    : PendingWant_1600
384  * @tc.name      : PendingWant GetForegroundService
385  * @tc.desc      : 1.Get pendingWant (context is nullptr)
386  */
387 HWTEST_F(PendingWantTest, PendingWant_1600, Function | MediumTest | Level1)
388 {
389     int requestCode = 10;
390     std::shared_ptr<Want> want = std::make_shared<Want>();
391     ElementName element("device", "bundleName", "abilityName");
392     want->SetElement(element);
393     unsigned int flags = 1;
394     flags |= FLAG_NO_CREATE;
395     std::shared_ptr<PendingWant> pendingWant = nullptr;
396     PendingWant::GetForegroundService(nullptr, requestCode, want, flags, pendingWant);
397     EXPECT_EQ(pendingWant, nullptr);
398 }
399 
400 /*
401  * @tc.number    : PendingWant_1700
402  * @tc.name      : PendingWant GetForegroundService
403  * @tc.desc      : 1.Get pendingWant (want is nullptr)
404  */
405 HWTEST_F(PendingWantTest, PendingWant_1700, Function | MediumTest | Level1)
406 {
407     int requestCode = 10;
408     std::shared_ptr<Want> want;
409     unsigned int flags = 1;
410     flags |= FLAG_ONE_SHOT;
411     WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
412     std::shared_ptr<PendingWant> pendingWant = nullptr;
413     PendingWant::BuildServicePendingWant(GetAppContext(), requestCode, want, flags, type, pendingWant);
414     EXPECT_NE(pendingWant, nullptr);
415 }
416 
417 /*
418  * @tc.number    : PendingWant_1800
419  * @tc.name      : PendingWant GetForegroundService
420  * @tc.desc      : 1.Get pendingWant (context is nullptr)
421  */
422 HWTEST_F(PendingWantTest, PendingWant_1800, Function | MediumTest | Level1)
423 {
424     int requestCode = 10;
425     std::shared_ptr<Want> want = std::make_shared<Want>();
426     ElementName element("device", "bundleName", "abilityName");
427     want->SetElement(element);
428     unsigned int flags = 1;
429     flags |= FLAG_NO_CREATE;
430     WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
431     std::shared_ptr<PendingWant> pendingWant = nullptr;
432     PendingWant::BuildServicePendingWant(nullptr, requestCode, want, flags, type, pendingWant);
433     EXPECT_EQ(pendingWant, nullptr);
434 }
435 
436 /*
437  * @tc.number    : PendingWant_1900
438  * @tc.name      : PendingWant Equals
439  * @tc.desc      : 1.Equals
440  */
441 HWTEST_F(PendingWantTest, PendingWant_1900, Function | MediumTest | Level1)
442 {
443     int requestCode = 10;
444     std::shared_ptr<Want> want = std::make_shared<Want>();
445     ElementName element("device", "bundleName", "abilityName");
446     want->SetElement(element);
447     unsigned int flags = 1;
448     flags |= FLAG_ONE_SHOT;
449     WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
450     std::shared_ptr<AbilityRuntime::ApplicationContext> context =
451         AbilityRuntime::ApplicationContext::GetInstance();
452     std::shared_ptr<PendingWant> pendingWant = nullptr;
453     PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
454 
455     sptr<AAFwk::IWantSender> target2(nullptr);
456     std::shared_ptr<PendingWant> pendingWant2 = std::make_shared<PendingWant>(target2);
457     EXPECT_NE(pendingWant->IsEquals(pendingWant, pendingWant2), ERR_OK);
458 }
459 
460 /*
461  * @tc.number    : PendingWant_2000
462  * @tc.name      : PendingWant Equals
463  * @tc.desc      : 1.Equals
464  */
465 HWTEST_F(PendingWantTest, PendingWant_2000, Function | MediumTest | Level1)
466 {
467     sptr<AAFwk::IWantSender> target(new (std::nothrow) PendingWantRecord());
468     std::shared_ptr<PendingWant> pendingWant = std::make_shared<PendingWant>(target);
469     std::shared_ptr<PendingWant> pendingWant2(nullptr);
470     EXPECT_NE(pendingWant->IsEquals(pendingWant, pendingWant2), ERR_OK);
471 }
472 
473 /*
474  * @tc.number    : PendingWant_2100
475  * @tc.name      : PendingWant SendAndReturnResult
476  * @tc.desc      : SendAndReturnResult
477  */
478 HWTEST_F(PendingWantTest, PendingWant_2100, Function | MediumTest | Level1)
479 {
480     PendingWant pendingWant(nullptr);
481     int requestCode = 10;
482     std::shared_ptr<Want> want = std::make_shared<Want>();
483     ElementName element("device", "bundleName", "abilityName");
484     want->SetElement(element);
485     bool value = true;
486     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
487     std::string key = "key";
488     wParams->SetParam(key, Boolean::Box(value));
489     unsigned int flags = 1;
490     flags |= FLAG_NO_CREATE;
491     AbilityManagerClient::GetInstance()->Connect();
492     EXPECT_EQ(ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT,
493         pendingWant.SendAndReturnResult(requestCode, want, nullptr, "Permission", nullptr, nullptr, nullptr));
494 }
495 
496 /*
497  * @tc.number    : PendingWant_2400
498  * @tc.name      : PendingWant GetTarget
499  * @tc.desc      : 1.GetTarget
500  */
501 HWTEST_F(PendingWantTest, PendingWant_2400, Function | MediumTest | Level1)
502 {
503     PendingWant pendingWant(nullptr);
504     auto target = pendingWant.GetTarget();
505     EXPECT_EQ(target, nullptr);
506 }
507 
508 /*
509  * @tc.number    : PendingWant_2500
510  * @tc.name      : PendingWant GetTarget
511  * @tc.desc      : 1.GetTarget
512  */
513 HWTEST_F(PendingWantTest, PendingWant_2500, Function | MediumTest | Level1)
514 {
515     sptr<AAFwk::IWantSender> target(new (std::nothrow) PendingWantRecord());
516     PendingWant pendingWant(target);
517     auto target1 = pendingWant.GetTarget();
518     EXPECT_EQ(target1, target);
519 }
520 
521 /*
522  * @tc.number    : PendingWant_2600
523  * @tc.name      : PendingWant RegisterCancelListener
524  * @tc.desc      : 1.RegisterCancelListener
525  */
526 HWTEST_F(PendingWantTest, PendingWant_2600, Function | MediumTest | Level1)
527 {
528     PendingWant pendingWant(nullptr);
529     std::shared_ptr<CancelListener> cancelListener1 = std::make_shared<CancelListenerSon>();
530     std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
531     pendingWant.RegisterCancelListener(cancelListener1, nullptr);
532     pendingWant.RegisterCancelListener(cancelListener2, nullptr);
533     EXPECT_EQ(static_cast<int>(pendingWant.cancelListeners_.size()), 2);
534 }
535 
536 /*
537  * @tc.number    : PendingWant_2700
538  * @tc.name      : PendingWant RegisterCancelListener
539  * @tc.desc      : 1.RegisterCancelListener
540  */
541 HWTEST_F(PendingWantTest, PendingWant_2700, Function | MediumTest | Level1)
542 {
543     PendingWant pendingWant(nullptr);
544     std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
545     pendingWant.RegisterCancelListener(nullptr, nullptr);
546     pendingWant.RegisterCancelListener(cancelListener2, nullptr);
547     EXPECT_EQ(static_cast<int>(pendingWant.cancelListeners_.size()), 1);
548 }
549 
550 /*
551  * @tc.number    : PendingWant_2800
552  * @tc.name      : PendingWant RegisterCancelListener
553  * @tc.desc      : 1.RegisterCancelListener
554  */
555 HWTEST_F(PendingWantTest, PendingWant_2800, Function | MediumTest | Level1)
556 {
557     PendingWant pendingWant(nullptr);
558     pendingWant.RegisterCancelListener(nullptr, nullptr);
559     pendingWant.RegisterCancelListener(nullptr, nullptr);
560     EXPECT_EQ(static_cast<int>(pendingWant.cancelListeners_.size()), 0);
561 }
562 
563 /*
564  * @tc.number    : PendingWant_2900
565  * @tc.name      : PendingWant NotifyCancelListeners
566  * @tc.desc      : 1.NotifyCancelListeners
567  */
568 HWTEST_F(PendingWantTest, PendingWant_2900, Function | MediumTest | Level1)
569 {
570     PendingWant pendingWant(nullptr);
571     std::shared_ptr<CancelListener> cancelListener1 = std::make_shared<CancelListenerSon>();
572     std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
573     pendingWant.RegisterCancelListener(cancelListener1, nullptr);
574     pendingWant.RegisterCancelListener(cancelListener2, nullptr);
575     pendingWant.NotifyCancelListeners(0);
576     EXPECT_EQ(callBackCancelListenerConnt, 2);
577     callBackCancelListenerConnt = 0;
578 }
579 
580 /*
581  * @tc.number    : PendingWant_3000
582  * @tc.name      : PendingWant NotifyCancelListeners
583  * @tc.desc      : 1.NotifyCancelListeners
584  */
585 HWTEST_F(PendingWantTest, PendingWant_3000, Function | MediumTest | Level1)
586 {
587     PendingWant pendingWant(nullptr);
588     std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
589     pendingWant.RegisterCancelListener(nullptr, nullptr);
590     pendingWant.RegisterCancelListener(cancelListener2, nullptr);
591     pendingWant.NotifyCancelListeners(0);
592     EXPECT_EQ(callBackCancelListenerConnt, 1);
593     callBackCancelListenerConnt = 0;
594 }
595 
596 /*
597  * @tc.number    : PendingWant_3100
598  * @tc.name      : PendingWant NotifyCancelListeners
599  * @tc.desc      : 1.NotifyCancelListeners
600  */
601 HWTEST_F(PendingWantTest, PendingWant_3100, Function | MediumTest | Level1)
602 {
603     PendingWant pendingWant(nullptr);
604     pendingWant.RegisterCancelListener(nullptr, nullptr);
605     pendingWant.RegisterCancelListener(nullptr, nullptr);
606     pendingWant.NotifyCancelListeners(0);
607     EXPECT_EQ(callBackCancelListenerConnt, 0);
608     callBackCancelListenerConnt = 0;
609 }
610 
611 /*
612  * @tc.number    : PendingWant_3200
613  * @tc.name      : PendingWant UnregisterCancelListener
614  * @tc.desc      : 1.UnregisterCancelListener
615  */
616 HWTEST_F(PendingWantTest, PendingWant_3200, Function | MediumTest | Level1)
617 {
618     PendingWant pendingWant(nullptr);
619     std::shared_ptr<CancelListener> cancelListener1 = std::make_shared<CancelListenerSon>();
620     std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
621     pendingWant.RegisterCancelListener(cancelListener1, nullptr);
622     pendingWant.RegisterCancelListener(cancelListener2, nullptr);
623     EXPECT_EQ(static_cast<int>(pendingWant.cancelListeners_.size()), 2);
624     pendingWant.UnregisterCancelListener(cancelListener1, nullptr);
625     EXPECT_EQ(static_cast<int>(pendingWant.cancelListeners_.size()), 1);
626 }
627 
628 /*
629  * @tc.number    : PendingWant_3300
630  * @tc.name      : PendingWant UnregisterCancelListener
631  * @tc.desc      : 1.UnregisterCancelListener
632  */
633 HWTEST_F(PendingWantTest, PendingWant_3300, Function | MediumTest | Level1)
634 {
635     PendingWant pendingWant(nullptr);
636     std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
637     pendingWant.RegisterCancelListener(nullptr, nullptr);
638     pendingWant.RegisterCancelListener(cancelListener2, nullptr);
639     EXPECT_EQ(static_cast<int>(pendingWant.cancelListeners_.size()), 1);
640     pendingWant.UnregisterCancelListener(cancelListener2, nullptr);
641     EXPECT_EQ(static_cast<int>(pendingWant.cancelListeners_.size()), 0);
642 }
643 
644 /*
645  * @tc.number    : PendingWant_3400
646  * @tc.name      : PendingWant UnregisterCancelListener
647  * @tc.desc      : 1.UnregisterCancelListener
648  */
649 HWTEST_F(PendingWantTest, PendingWant_3400, Function | MediumTest | Level1)
650 {
651     PendingWant pendingWant(nullptr);
652     pendingWant.UnregisterCancelListener(nullptr, nullptr);
653     EXPECT_EQ(static_cast<int>(pendingWant.cancelListeners_.size()), 0);
654 }
655 
656 /*
657  * @tc.number    : PendingWant_3500
658  * @tc.name      : PendingWant GetWant
659  * @tc.desc      : 1.GetWant
660  */
661 HWTEST_F(PendingWantTest, PendingWant_3500, Function | MediumTest | Level1)
662 {
663     PendingWant pendingWant(nullptr);
664     auto want = pendingWant.GetWant(nullptr);
665     EXPECT_EQ(want, nullptr);
666 }
667 
668 /*
669  * @tc.number    : PendingWant_3600
670  * @tc.name      : PendingWant Equals
671  * @tc.desc      : Equals
672  */
673 HWTEST_F(PendingWantTest, PendingWant_3700, Function | MediumTest | Level1)
674 {
675     std::shared_ptr<PendingWant> pendingWant(nullptr);
676     std::shared_ptr<PendingWant> pendingWant2(nullptr);
677     EXPECT_EQ(pendingWant->IsEquals(pendingWant, pendingWant2), ERR_OK);
678 }
679 
680 /*
681  * @tc.number    : PendingWant_3800
682  * @tc.name      : Marshalling_01
683  * @tc.desc      : test Marshalling function when target is null
684  * tc.issue      : I5TGRZ
685  */
686 HWTEST_F(PendingWantTest, PendingWant_3800, Function | MediumTest | Level1)
687 {
688     PendingWant pendingWant(nullptr);
689     Parcel parcel;
690     bool ret = pendingWant.Marshalling(parcel);
691     EXPECT_EQ(ret, false);
692 }
693 
694 /*
695  * @tc.number    : PendingWant_3900
696  * @tc.name      : Marshalling_02
697  * @tc.desc      : test Marshalling function when target is target
698  * tc.issue      : I5TGRZ
699  */
700 HWTEST_F(PendingWantTest, PendingWant_3900, Function | MediumTest | Level1)
701 {
702     sptr<AAFwk::IWantSender> target(new (std::nothrow) PendingWantRecord());
703     PendingWant pendingWant(target);
704     MessageParcel parcel;
705     bool ret = pendingWant.Marshalling(parcel);
706     EXPECT_EQ(ret, true);
707 }
708 
709 /*
710  * @tc.number    : PendingWant_4000
711  * @tc.name      : PendingWant GetType
712  * @tc.desc      : 1.Get PendingWant Type (UNKNOWN_TYPE)
713  */
714 HWTEST_F(PendingWantTest, PendingWant_4000, Function | MediumTest | Level1)
715 {
716     sptr<AAFwk::IWantSender> target = nullptr;
717     PendingWant pendingWant(target);
718     EXPECT_EQ(pendingWant.target_, target);
719     int32_t type = static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE);
720     EXPECT_EQ(pendingWant.GetType(target, type), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
721     EXPECT_EQ(type, static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE));
722 }
723 
724 /*
725  * @tc.number    : PendingWant_4100
726  * @tc.name      : PendingWant GetWant
727  * @tc.desc      : 1.GetWant
728  */
729 HWTEST_F(PendingWantTest, PendingWant_4100, Function | MediumTest | Level1)
730 {
731     sptr<AAFwk::IWantSender> target = nullptr;
732     PendingWant pendingWant(target);
733     EXPECT_EQ(pendingWant.target_, target);
734     std::shared_ptr<AAFwk::Want> want(nullptr);
735     EXPECT_EQ(pendingWant.GetWant(target, want), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
736     EXPECT_EQ(want, nullptr);
737 }
738 
739 /*
740  * @tc.number    : PendingWant_4200
741  * @tc.name      : PendingWant GetBundleName
742  * @tc.desc      : 1.GetBundleName
743  */
744 HWTEST_F(PendingWantTest, PendingWant_4200, Function | MediumTest | Level1)
745 {
746     PendingWant pendingWant(nullptr);
747     std::string bundleName = "";
748     pendingWant.GetBundleName(nullptr, bundleName);
749     EXPECT_EQ(bundleName, "");
750 }
751 
752 /*
753  * @tc.number    : PendingWant_4300
754  * @tc.name      : PendingWant GetUid
755  * @tc.desc      : 1.GetUid
756  */
757 HWTEST_F(PendingWantTest, PendingWant_4300, Function | MediumTest | Level1)
758 {
759     auto pendingWant = std::make_shared<PendingWant>(nullptr);
760     EXPECT_NE(pendingWant, nullptr);
761     int32_t uid = -1;
762     pendingWant->GetUid(nullptr, uid);
763 }
764 
765 /*
766  * @tc.number    : PendingWant_4400
767  * @tc.name      : PendingWant Send
768  * @tc.desc      : Send
769  */
770 HWTEST_F(PendingWantTest, PendingWant_4400, Function | MediumTest | Level1)
771 {
772     GTEST_LOG_(INFO) << "PendingWant_4400 start";
773     PendingWant pendingWant(nullptr);
774     sptr<AAFwk::IWantSender> target;
775     pendingWant.Send(target);
776     EXPECT_TRUE(true);
777     GTEST_LOG_(INFO) << "PendingWant_4400 end";
778 }
779 
780 /*
781  * @tc.number    : PendingWant_4500
782  * @tc.name      : PendingWant Send
783  * @tc.desc      : Send
784  */
785 HWTEST_F(PendingWantTest, PendingWant_4500, Function | MediumTest | Level1)
786 {
787     GTEST_LOG_(INFO) << "PendingWant_4500 start";
788     PendingWant pendingWant(nullptr);
789     int requestCode = 10;
790     sptr<AAFwk::IWantSender> target;
791     pendingWant.Send(requestCode, target);
792     EXPECT_TRUE(true);
793     GTEST_LOG_(INFO) << "PendingWant_4500 end";
794 }
795 
796 /*
797  * @tc.number    : PendingWant_4600
798  * @tc.name      : PendingWant Send
799  * @tc.desc      : Send
800  */
801 HWTEST_F(PendingWantTest, PendingWant_4600, Function | MediumTest | Level1)
802 {
803     GTEST_LOG_(INFO) << "PendingWant_4600 start";
804     PendingWant pendingWant(nullptr);
805     int requestCode = 10;
806     std::shared_ptr<Want> want = std::make_shared<Want>();
807     ElementName element("device", "bundleName", "abilityName");
808     want->SetElement(element);
809     sptr<AAFwk::IWantSender> target;
810     pendingWant.Send(requestCode, want, target);
811     EXPECT_TRUE(true);
812     GTEST_LOG_(INFO) << "PendingWant_4600 end";
813 }
814 
815 /*
816  * @tc.number    : PendingWant_4700
817  * @tc.name      : PendingWant Send
818  * @tc.desc      : Send
819  */
820 HWTEST_F(PendingWantTest, PendingWant_4700, Function | MediumTest | Level1)
821 {
822     GTEST_LOG_(INFO) << "PendingWant_4700 start";
823     PendingWant pendingWant(nullptr);
824     int requestCode = 10;
825     sptr<CompletedDispatcher> onCompleted;
826     sptr<AAFwk::IWantSender> target;
827     pendingWant.Send(requestCode, onCompleted, target);
828     EXPECT_TRUE(true);
829     GTEST_LOG_(INFO) << "PendingWant_4700 end";
830 }
831 
832 /*
833  * @tc.number    : PendingWant_4800
834  * @tc.name      : PendingWant Send
835  * @tc.desc      : Send
836  */
837 HWTEST_F(PendingWantTest, PendingWant_4800, Function | MediumTest | Level1)
838 {
839     GTEST_LOG_(INFO) << "PendingWant_4800 start";
840     PendingWant pendingWant(nullptr);
841     int requestCode = 10;
842     std::shared_ptr<Want> want = std::make_shared<Want>();
843     ElementName element("device", "bundleName", "abilityName");
844     want->SetElement(element);
845     sptr<CompletedDispatcher> onCompleted;
846     sptr<AAFwk::IWantSender> target;
847     pendingWant.Send(requestCode, want, onCompleted, target);
848     EXPECT_TRUE(true);
849     GTEST_LOG_(INFO) << "PendingWant_4800 end";
850 }
851 
852 /*
853  * @tc.number    : PendingWant_4900
854  * @tc.name      : PendingWant Send
855  * @tc.desc      : Send
856  */
857 HWTEST_F(PendingWantTest, PendingWant_4900, Function | MediumTest | Level1)
858 {
859     GTEST_LOG_(INFO) << "PendingWant_4900 start";
860     PendingWant pendingWant(nullptr);
861     int requestCode = 10;
862     std::shared_ptr<Want> want = std::make_shared<Want>();
863     ElementName element("device", "bundleName", "abilityName");
864     want->SetElement(element);
865     sptr<CompletedDispatcher> onCompleted = nullptr;
866     std::string requiredPermission = "Permission";
867     sptr<AAFwk::IWantSender> target;
868     pendingWant.Send(requestCode, want, onCompleted, requiredPermission, target);
869     EXPECT_TRUE(true);
870     GTEST_LOG_(INFO) << "PendingWant_4900 end";
871 }
872 
873 /*
874  * @tc.number    : PendingWant_5000
875  * @tc.name      : PendingWant Send
876  * @tc.desc      : Send
877  */
878 HWTEST_F(PendingWantTest, PendingWant_5000, Function | MediumTest | Level1)
879 {
880     GTEST_LOG_(INFO) << "PendingWant_5000 start";
881     PendingWant pendingWant(nullptr);
882     int requestCode = 10;
883     std::shared_ptr<Want> want = std::make_shared<Want>();
884     ElementName element("device", "bundleName", "abilityName");
885     want->SetElement(element);
886     sptr<CompletedDispatcher> onCompleted;
887     std::string requiredPermission = "Permission";
888     std::shared_ptr<WantParams> options;
889     std::shared_ptr<StartOptions> startOptions = nullptr;
890     sptr<AAFwk::IWantSender> target;
891     pendingWant.Send(requestCode, want, onCompleted, requiredPermission, options, startOptions, target);
892     EXPECT_TRUE(true);
893     GTEST_LOG_(INFO) << "PendingWant_5000 end";
894 }
895 
896 /*
897  * @tc.number    : PendingWant_5100
898  * @tc.name      : PendingWant SetTarget
899  * @tc.desc      : SetTarget
900  */
901 HWTEST_F(PendingWantTest, PendingWant_5100, Function | MediumTest | Level1)
902 {
903     sptr<AAFwk::IWantSender> target(new (std::nothrow) PendingWantRecord());
904     PendingWant pendingWant(nullptr);
905     auto target1 = pendingWant.GetTarget();
906     pendingWant.SetTarget(target);
907     auto target2 = pendingWant.GetTarget();
908     EXPECT_EQ(target1, nullptr);
909     EXPECT_EQ(target2, target);
910 }
911 
912 /*
913  * @tc.number    : PendingWant_5200
914  * @tc.name      : Unmarshalling_01
915  * @tc.desc      : Test Unmarshalling function when target is null
916  */
917 HWTEST_F(PendingWantTest, PendingWant_5200, Function | MediumTest | Level1)
918 {
919     sptr<AAFwk::IWantSender> target(new (std::nothrow) PendingWantRecord());
920     PendingWant pendingWant(target);
921     MessageParcel parcel;
922     pendingWant.Unmarshalling(parcel);
923     auto target1 = pendingWant.GetTarget();
924     EXPECT_EQ(target1, target);
925 }
926 
927 /*
928  * @tc.number    : PendingWant_5300
929  * @tc.name      : PendingWant GetWantSenderInfo
930  * @tc.desc      : GetWantSenderInfo
931  */
932 HWTEST_F(PendingWantTest, PendingWant_5300, Function | MediumTest | Level1)
933 {
934     PendingWant pendingWant(nullptr);
935     auto wantsenderinfo = pendingWant.GetWantSenderInfo(nullptr);
936     EXPECT_EQ(wantsenderinfo, nullptr);
937 }
938 
939 /*
940  * @tc.number    : PendingWant_5400
941  * @tc.name      : PendingWant NotifyCancelListeners
942  * @tc.desc      : NotifyCancelListeners
943  */
944 HWTEST_F(PendingWantTest, PendingWant_5400, Function | MediumTest | Level1)
945 {
946     std::shared_ptr<PendingWant> pendingWant = std::make_shared<PendingWant>(nullptr);
947     std::shared_ptr<CancelListener> cancelListener1 = std::make_shared<CancelListenerSon>();
948     std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
949     pendingWant->RegisterCancelListener(cancelListener1, nullptr);
950     pendingWant->RegisterCancelListener(cancelListener2, nullptr);
951     std::weak_ptr<PendingWant> outerInstance(pendingWant);
952     PendingWant::CancelReceiver cancelreceiver(outerInstance);
953     cancelreceiver.Send(0);
954 
955     EXPECT_EQ(callBackCancelListenerConnt, 2);
956     callBackCancelListenerConnt = 0;
957 }
958 
959 /*
960  * @tc.number    : PendingWant_5500
961  * @tc.name      : PendingWant GetAbilitys
962  * @tc.desc      : 1.Get pendingWant (context is nullptr)
963  */
964 HWTEST_F(PendingWantTest, PendingWant_5500, Function | MediumTest | Level1)
965 {
966     TAG_LOGI(AAFwkTag::TEST, "PendingWant_5500 start.");
967     int requestCode = 10;
968     std::shared_ptr<Want> want = std::make_shared<Want>();
969     ElementName element("device", "bundleName", "abilityName");
970     want->SetElement(element);
971     std::shared_ptr<Want> want2 = std::make_shared<Want>();
972     ElementName element2("device", "bundleName", "abilityName");
973     want2->SetElement(element2);
974     std::vector<std::shared_ptr<Want>> wants;
975     wants.emplace_back(want);
976     wants.emplace_back(want2);
977     bool value = true;
978     std::string key = "key";
979     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
980     wParams->SetParam(key, Boolean::Box(value));
981     unsigned int flags = 1;
982     flags |= FLAG_NO_CREATE;
983     std::shared_ptr<PendingWant> pendingWant;
984     ErrCode err = PendingWant::GetAbilities(nullptr, requestCode, wants, flags, wParams, pendingWant);
985     EXPECT_EQ(err, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
986     TAG_LOGI(AAFwkTag::TEST, "PendingWant_5500 end.");
987 }
988 
989 /*
990  * @tc.number    : PendingWant_5600
991  * @tc.name      : PendingWant GetAbilities
992  * @tc.desc      : 1.Get pendingWant (context is not nullptr FLAG_NO_CREATE)
993  */
994 HWTEST_F(PendingWantTest, PendingWant_5600, Function | MediumTest | Level1)
995 {
996     TAG_LOGI(AAFwkTag::TEST, "PendingWant_5600 start.");
997     int requestCode = 10;
998     std::shared_ptr<Want> want = std::make_shared<Want>();
999     ElementName element("device", "bundleName", "abilityName");
1000     want->SetElement(element);
1001     std::shared_ptr<Want> want2 = std::make_shared<Want>();
1002     ElementName element2("device", "bundleName", "abilityName");
1003     want2->SetElement(element2);
1004     std::vector<std::shared_ptr<Want>> wants;
1005     wants.emplace_back(want);
1006     wants.emplace_back(want2);
1007     bool value = true;
1008     std::string key = "key";
1009     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1010     wParams->SetParam(key, Boolean::Box(value));
1011     unsigned int flags = 1;
1012     flags |= FLAG_NO_CREATE;
1013     std::shared_ptr<PendingWant> pendingWant;
1014     ErrCode err = PendingWant::GetAbilities(GetAppContext(), requestCode, wants, flags, wParams, pendingWant);
1015     EXPECT_EQ(err, ERR_OK);
1016     TAG_LOGI(AAFwkTag::TEST, "PendingWant_5600 end.");
1017 }
1018 
1019 /*
1020  * @tc.number    : PendingWant_5700
1021  * @tc.name      : PendingWant GetAbilities
1022  * @tc.desc      : 1.Get pendingWant (context is not nullptr FLAG_ONE_SHOT)
1023  */
1024 HWTEST_F(PendingWantTest, PendingWant_5700, Function | MediumTest | Level1)
1025 {
1026     TAG_LOGI(AAFwkTag::TEST, "PendingWant_5700 start.");
1027     int requestCode = 10;
1028     std::shared_ptr<Want> want = std::make_shared<Want>();
1029     ElementName element("device", "bundleName", "abilityName");
1030     want->SetElement(element);
1031     std::shared_ptr<Want> want2 = std::make_shared<Want>();
1032     ElementName element2("device", "bundleName", "abilityName");
1033     want2->SetElement(element2);
1034     std::vector<std::shared_ptr<Want>> wants;
1035     wants.emplace_back(want);
1036     wants.emplace_back(want2);
1037     bool value = true;
1038     std::string key = "key";
1039     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1040     wParams->SetParam(key, Boolean::Box(value));
1041     unsigned int flags = 1;
1042     flags |= FLAG_ONE_SHOT;
1043     std::shared_ptr<PendingWant> pendingWant;
1044     ErrCode err = PendingWant::GetAbilities(GetAppContext(), requestCode, wants, flags, wParams, pendingWant);
1045     EXPECT_EQ(err, ERR_OK);
1046     TAG_LOGI(AAFwkTag::TEST, "PendingWant_5700 end.");
1047 }
1048 
1049 /*
1050  * @tc.number    : PendingWant_5800
1051  * @tc.name      : PendingWant GetAbilitie
1052  * @tc.desc      : 1.Get pendingWant (context is nullptr)
1053  */
1054 HWTEST_F(PendingWantTest, PendingWant_5800, Function | MediumTest | Level1)
1055 {
1056     TAG_LOGI(AAFwkTag::TEST, "PendingWant_5800 start.");
1057     int requestCode = 10;
1058     std::shared_ptr<Want> want = std::make_shared<Want>();
1059     ElementName element("device", "bundleName", "abilityName");
1060     want->SetElement(element);
1061     bool value = true;
1062     std::string key = "key";
1063     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1064     wParams->SetParam(key, Boolean::Box(value));
1065     unsigned int flags = 1;
1066     flags |= FLAG_ONE_SHOT;
1067     std::shared_ptr<PendingWant> pendingWant;
1068     ErrCode err = PendingWant::GetAbility(nullptr, requestCode, want, flags, wParams, pendingWant);
1069     EXPECT_EQ(err, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1070     TAG_LOGI(AAFwkTag::TEST, "PendingWant_5800 end.");
1071 }
1072 
1073 /*
1074  * @tc.number    : PendingWant_5800
1075  * @tc.name      : PendingWant GetAbilitie
1076  * @tc.desc      : 1.Get pendingWant (context not nullptr)
1077  */
1078 HWTEST_F(PendingWantTest, PendingWant_5900, Function | MediumTest | Level1)
1079 {
1080     TAG_LOGI(AAFwkTag::TEST, "PendingWant_5900 start.");
1081     int requestCode = 10;
1082     std::shared_ptr<Want> want = std::make_shared<Want>();
1083     ElementName element("device", "bundleName", "abilityName");
1084     want->SetElement(element);
1085     bool value = true;
1086     std::string key = "key";
1087     std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1088     wParams->SetParam(key, Boolean::Box(value));
1089     unsigned int flags = 1;
1090     flags |= FLAG_ONE_SHOT;
1091     std::shared_ptr<PendingWant> pendingWant;
1092     ErrCode err = PendingWant::GetAbility(GetAppContext(), requestCode, want, flags, wParams, pendingWant);
1093     EXPECT_EQ(err, ERR_OK);
1094     TAG_LOGI(AAFwkTag::TEST, "PendingWant_5900 end.");
1095 }
1096 
1097 /*
1098  * @tc.number    : PendingWant_6000
1099  * @tc.name      : PendingWant GetCommonEvent
1100  * @tc.desc      : 1.Get pendingWant (context is nullptr)
1101  */
1102 HWTEST_F(PendingWantTest, PendingWant_6000, Function | MediumTest | Level1)
1103 {
1104     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6000 start.");
1105     int requestCode = 10;
1106     std::shared_ptr<Want> want = std::make_shared<Want>();
1107     ElementName element("device", "bundleName", "abilityName");
1108     want->SetElement(element);
1109     unsigned int flags = 1;
1110     flags |= FLAG_NO_CREATE;
1111     std::shared_ptr<PendingWant> pendingWant;
1112     ErrCode err = PendingWant::GetCommonEvent(nullptr, requestCode, want, flags, pendingWant);
1113     EXPECT_EQ(err, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1114     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6000 end.");
1115 }
1116 
1117 /*
1118  * @tc.number    : PendingWant_6100
1119  * @tc.name      : PendingWant GetCommonEvent
1120  * @tc.desc      : 1.Get pendingWant (context is not nullptr)
1121  */
1122 HWTEST_F(PendingWantTest, PendingWant_6100, Function | MediumTest | Level1)
1123 {
1124     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6100 start.");
1125     int requestCode = 10;
1126     std::shared_ptr<Want> want = std::make_shared<Want>();
1127     ElementName element("device", "bundleName", "abilityName");
1128     want->SetElement(element);
1129     unsigned int flags = 1;
1130     flags |= FLAG_ONE_SHOT;
1131     std::shared_ptr<PendingWant> pendingWant;
1132     ErrCode err = PendingWant::GetCommonEvent(GetAppContext(), requestCode, want, flags, pendingWant);
1133     EXPECT_EQ(err, ERR_OK);
1134     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6100 end.");
1135 }
1136 
1137 /*
1138  * @tc.number    : PendingWant_6200
1139  * @tc.name      : PendingWant GetService
1140  * @tc.desc      : 1.Get pendingWant (context is nullptr)
1141  */
1142 HWTEST_F(PendingWantTest, PendingWant_6200, Function | MediumTest | Level1)
1143 {
1144     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6200 start.");
1145     int requestCode = 10;
1146     std::shared_ptr<Want> want = std::make_shared<Want>();
1147     ElementName element("device", "bundleName", "abilityName");
1148     want->SetElement(element);
1149     unsigned int flags = 1;
1150     flags |= FLAG_NO_CREATE;
1151     std::shared_ptr<PendingWant> pendingWant;
1152     ErrCode err = PendingWant::GetService(nullptr, requestCode, want, flags, pendingWant);
1153     EXPECT_EQ(err, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1154     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6200 end.");
1155 }
1156 
1157 /*
1158  * @tc.number    : PendingWant_6300
1159  * @tc.name      : PendingWant GetService
1160  * @tc.desc      : 1.Get pendingWant (context is not nullptr)
1161  */
1162 HWTEST_F(PendingWantTest, PendingWant_6300, Function | MediumTest | Level1)
1163 {
1164     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6300 start.");
1165     int requestCode = 10;
1166     std::shared_ptr<Want> want = std::make_shared<Want>();
1167     ElementName element("device", "bundleName", "abilityName");
1168     want->SetElement(element);
1169     unsigned int flags = 1;
1170     flags |= FLAG_NO_CREATE;
1171     std::shared_ptr<PendingWant> pendingWant;
1172     ErrCode err = PendingWant::GetService(nullptr, requestCode, want, flags, pendingWant);
1173     EXPECT_EQ(err, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1174     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6300 end.");
1175 }
1176 
1177 /*
1178  * @tc.number    : PendingWant_6400
1179  * @tc.name      : PendingWant GetService
1180  * @tc.desc      : 1.Get pendingWant (context is not nullptr)
1181  */
1182 HWTEST_F(PendingWantTest, PendingWant_6400, Function | MediumTest | Level1)
1183 {
1184     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6400 start.");
1185     int requestCode = 10;
1186     std::shared_ptr<Want> want = std::make_shared<Want>();
1187     ElementName element("device", "bundleName", "abilityName");
1188     want->SetElement(element);
1189     unsigned int flags = 1;
1190     flags |= FLAG_ONE_SHOT;
1191     std::shared_ptr<PendingWant> pendingWant;
1192     ErrCode err = PendingWant::GetService(GetAppContext(), requestCode, want, flags, pendingWant);
1193     EXPECT_EQ(err, ERR_OK);
1194     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6400 end.");
1195 }
1196 
1197 /*
1198  * @tc.number    : PendingWant_6500
1199  * @tc.name      : PendingWant GetService
1200  * @tc.desc      : 1.Get pendingWant (context is not nullptr)
1201  */
1202 HWTEST_F(PendingWantTest, PendingWant_6500, Function | MediumTest | Level1)
1203 {
1204     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6500 start.");
1205     int requestCode = 10;
1206     std::shared_ptr<Want> want = std::make_shared<Want>();
1207     ElementName element("device", "bundleName", "abilityName");
1208     want->SetElement(element);
1209     unsigned int flags = 1;
1210     flags |= FLAG_NO_CREATE;
1211     std::shared_ptr<PendingWant> pendingWant;
1212     ErrCode err = PendingWant::GetForegroundService(GetAppContext(), requestCode, want, flags, pendingWant);
1213     EXPECT_EQ(err, ERR_OK);
1214     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6500 start.");
1215 }
1216 
1217 /*
1218  * @tc.number    : PendingWant_6600
1219  * @tc.name      : PendingWant GetService
1220  * @tc.desc      : 1.Get pendingWant (context is nullptr)
1221  */
1222 HWTEST_F(PendingWantTest, PendingWant_6600, Function | MediumTest | Level1)
1223 {
1224     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6600 start.");
1225     int requestCode = 10;
1226     std::shared_ptr<Want> want = std::make_shared<Want>();
1227     ElementName element("device", "bundleName", "abilityName");
1228     want->SetElement(element);
1229     unsigned int flags = 1;
1230     flags |= FLAG_NO_CREATE;
1231     std::shared_ptr<PendingWant> pendingWant;
1232     ErrCode err = PendingWant::GetForegroundService(nullptr, requestCode, want, flags, pendingWant);
1233     EXPECT_EQ(err, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1234     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6500 end.");
1235 }
1236 
1237 /*
1238  * @tc.number    : PendingWant_6700
1239  * @tc.name      : PendingWant Cancel
1240  * @tc.desc      : Cancel a WantAgent
1241  */
1242 HWTEST_F(PendingWantTest, PendingWant_6700, Function | MediumTest | Level1)
1243 {
1244     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6700 start.");
1245     sptr<AAFwk::IWantSender> target = nullptr;
1246     std::shared_ptr<PendingWant> pendingWant = std::make_shared<PendingWant>();
1247     ErrCode err = pendingWant->Cancel(target);
1248     ErrCode err1 = WantAgentClient::GetInstance().CancelWantSender(target);
1249     EXPECT_EQ(err, err1);
1250     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6700 end.");
1251 }
1252 
1253 /*
1254  * @tc.number    : PendingWant_6800
1255  * @tc.name      : PendingWant IsEquals
1256  * @tc.desc      : 1.IsEquals
1257  */
1258 HWTEST_F(PendingWantTest, PendingWant_6800, Function | MediumTest | Level1)
1259 {
1260     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6800 start.");
1261     int requestCode = 10;
1262     std::shared_ptr<Want> want = std::make_shared<Want>();
1263     ElementName element("device", "bundleName", "abilityName");
1264     want->SetElement(element);
1265     unsigned int flags = 1;
1266     flags |= FLAG_ONE_SHOT;
1267     WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
1268     std::shared_ptr<AbilityRuntime::ApplicationContext> context =
1269         AbilityRuntime::ApplicationContext::GetInstance();
1270     std::shared_ptr<PendingWant> pendingWant = nullptr;
1271     PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
1272 
1273     sptr<AAFwk::IWantSender> target(nullptr);
1274     std::shared_ptr<PendingWant> pendingWant2 = std::make_shared<PendingWant>(target);
1275     EXPECT_EQ(pendingWant->IsEquals(pendingWant, pendingWant2), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
1276     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6800 end.");
1277 }
1278 
1279 /*
1280  * @tc.number    : PendingWant_6900
1281  * @tc.name      : PendingWant IsEquals
1282  * @tc.desc      : 1.IsEquals
1283  */
1284 HWTEST_F(PendingWantTest, PendingWant_6900, Function | MediumTest | Level1)
1285 {
1286     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6900 start.");
1287     int requestCode = 10;
1288     std::shared_ptr<Want> want = std::make_shared<Want>();
1289     ElementName element("device", "bundleName", "abilityName");
1290     want->SetElement(element);
1291     unsigned int flags = 1;
1292     flags |= FLAG_ONE_SHOT;
1293     WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
1294     std::shared_ptr<AbilityRuntime::ApplicationContext> context =
1295         AbilityRuntime::ApplicationContext::GetInstance();
1296     std::shared_ptr<PendingWant> pendingWant = nullptr;
1297     PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
1298 
1299     std::shared_ptr<PendingWant> pendingWant2 = nullptr;
1300     PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant2);
1301     EXPECT_EQ(pendingWant->IsEquals(pendingWant, pendingWant2), ERR_OK);
1302     TAG_LOGI(AAFwkTag::TEST, "PendingWant_6900 end.");
1303 }
1304 
1305 /*
1306  * @tc.number    : PendingWant_7000
1307  * @tc.name      : PendingWant IsEquals
1308  * @tc.desc      : 1.IsEquals
1309  */
1310 HWTEST_F(PendingWantTest, PendingWant_7000, Function | MediumTest | Level1)
1311 {
1312     TAG_LOGI(AAFwkTag::TEST, "PendingWant_7000 start.");
1313     int requestCode = 10;
1314     std::shared_ptr<Want> want1 = std::make_shared<Want>();
1315     ElementName element1("ohos_device", "bundleName", "abilityName");
1316     want1->SetElement(element1);
1317     unsigned int flags = 1;
1318     flags |= FLAG_ONE_SHOT;
1319     WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
1320     std::shared_ptr<AbilityRuntime::ApplicationContext> context =
1321         AbilityRuntime::ApplicationContext::GetInstance();
1322     std::shared_ptr<PendingWant> pendingWant = nullptr;
1323     PendingWant::BuildServicePendingWant(context, requestCode, want1, flags, type, pendingWant);
1324 
1325     std::shared_ptr<Want> want2 = std::make_shared<Want>();
1326     ElementName element2("ohos_device", "ohos_bundleName", "ohos_abilityName");
1327     want2->SetElement(element2);
1328     std::shared_ptr<PendingWant> pendingWant2 = nullptr;
1329     PendingWant::BuildServicePendingWant(context, requestCode, want2, flags, type, pendingWant2);
1330     EXPECT_EQ(pendingWant->IsEquals(pendingWant, pendingWant2), NOTEQ);
1331     TAG_LOGI(AAFwkTag::TEST, "PendingWant_7000 end.");
1332 }
1333 
1334 /*
1335  * @tc.number    : PendingWant_7100
1336  * @tc.name      : PendingWant GetBundleName
1337  * @tc.desc      : 1.GetBundleName
1338  */
1339 HWTEST_F(PendingWantTest, PendingWant_7100, Function | MediumTest | Level1)
1340 {
1341     TAG_LOGI(AAFwkTag::TEST, "PendingWant_7100 start.");
1342     PendingWant pendingWant(nullptr);
1343     std::string bundleName;
1344     ErrCode err = pendingWant.GetBundleName(nullptr, bundleName);
1345     EXPECT_EQ(err, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
1346     TAG_LOGI(AAFwkTag::TEST, "PendingWant_7100 end.");
1347 }
1348 
1349 /*
1350  * @tc.number    : PendingWant_7200
1351  * @tc.name      : PendingWant GetBundleName
1352  * @tc.desc      : 1.GetBundleName
1353  */
1354 HWTEST_F(PendingWantTest, PendingWant_7200, Function | MediumTest | Level1)
1355 {
1356     TAG_LOGI(AAFwkTag::TEST, "PendingWant_7200 start.");
1357     int requestCode = 10;
1358     std::shared_ptr<Want> want1 = std::make_shared<Want>();
1359     ElementName element1("ohos_device", "bundleName", "abilityName");
1360     want1->SetElement(element1);
1361     unsigned int flags = 1;
1362     flags |= FLAG_ONE_SHOT;
1363     WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
1364     std::shared_ptr<AbilityRuntime::ApplicationContext> context =
1365         AbilityRuntime::ApplicationContext::GetInstance();
1366     std::shared_ptr<PendingWant> pendingWant = nullptr;
1367     PendingWant::BuildServicePendingWant(context, requestCode, want1, flags, type, pendingWant);
1368 
1369     std::string bundleName;
1370     ErrCode err = pendingWant->GetBundleName(pendingWant->GetTarget(), bundleName);
1371     EXPECT_EQ(err, ERR_OK);
1372     TAG_LOGI(AAFwkTag::TEST, "PendingWant_7200 start.");
1373 }
1374 
1375 /*
1376  * @tc.number    : PendingWant_7300
1377  * @tc.name      : PendingWant PerformReceive
1378  * @tc.desc      : 1.PerformReceive
1379  */
1380 HWTEST_F(PendingWantTest, PendingWant_7300, Function | MediumTest | Level1)
1381 {
1382     std::shared_ptr<PendingWant> pendingWant = std::make_shared<PendingWant>(nullptr);
1383     std::shared_ptr<CancelListener> cancelListener1 = std::make_shared<CancelListenerSon>();
1384     std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
1385     pendingWant->RegisterCancelListener(cancelListener1, nullptr);
1386     pendingWant->RegisterCancelListener(cancelListener2, nullptr);
1387     std::weak_ptr<PendingWant> outerInstance(pendingWant);
1388     PendingWant::CancelReceiver cancelreceiver(outerInstance);
1389     AAFwk::Want want;
1390     int resultCode = 1;
1391     std::string data = "";
1392     AAFwk::WantParams extras;
1393     bool serialized = true;
1394     bool sticky = true;
1395     int sendingUser = 1;
1396     cancelreceiver.PerformReceive(want, resultCode, data, extras, serialized, sticky, sendingUser);
1397 
1398     EXPECT_EQ(callBackCancelListenerConnt, 0);
1399     callBackCancelListenerConnt = 0;
1400 }
1401 
1402 /*
1403  * @tc.number    : PendingWant_7400
1404  * @tc.name      : PendingWant GetServiceExtension
1405  * @tc.desc      : 1.Get pendingWant (want is nullptr)
1406  */
1407 HWTEST_F(PendingWantTest, PendingWant_7400, Function | MediumTest | Level1)
1408 {
1409     int requestCode = 10;
1410     std::shared_ptr<Want> want;
1411     unsigned int flags = 1;
1412     flags |= FLAG_ONE_SHOT;
1413     std::shared_ptr<PendingWant> pendingWant = nullptr;
1414     PendingWant::GetServiceExtension(GetAppContext(), requestCode, want, flags, pendingWant);
1415     EXPECT_NE(pendingWant, nullptr);
1416 }
1417 
1418 /*
1419  * @tc.number    : PendingWant_7500
1420  * @tc.name      : PendingWant GetServiceExtension
1421  * @tc.desc      : 1.Get pendingWant (context is nullptr)
1422  */
1423 HWTEST_F(PendingWantTest, PendingWant_7500, Function | MediumTest | Level1)
1424 {
1425     int requestCode = 10;
1426     std::shared_ptr<Want> want = std::make_shared<Want>();
1427     ElementName element("device", "bundleName", "abilityName");
1428     want->SetElement(element);
1429     unsigned int flags = 1;
1430     flags |= FLAG_NO_CREATE;
1431     std::shared_ptr<PendingWant> pendingWant = nullptr;
1432     PendingWant::GetServiceExtension(nullptr, requestCode, want, flags, pendingWant);
1433     EXPECT_EQ(pendingWant, nullptr);
1434 }
1435 }  // namespace OHOS::AbilityRuntime::WantAgent
1436