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