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_context.h"
18 #include "ability_runtime_error_util.h"
19 #include <algorithm>
20 #include "completed_callback.h"
21 #include "context_container.h"
22 #include "context_impl.h"
23 #include "context/application_context.h"
24 #include "element_name.h"
25 #include "event_handler.h"
26 #include "base_types.h"
27 #define private public
28 #define protected public
29 #include "pending_want.h"
30 #include "remote_native_token.h"
31 #undef private
32 #undef protected
33 #include "want.h"
34 #include "want_agent.h"
35 #include "want_agent_constant.h"
36 #define private public
37 #define protected public
38 #include "want_agent_helper.h"
39 #include "want_agent_client.h"
40 #include "want_agent_info.h"
41 #undef private
42 #undef protected
43 #include "want_params.h"
44 #include "want_receiver_stub.h"
45 #include "want_sender_stub.h"
46 #include "bool_wrapper.h"
47
48 using namespace testing::ext;
49 using namespace OHOS::AAFwk;
50 using namespace OHOS;
51 using OHOS::AppExecFwk::ElementName;
52 using namespace OHOS::AbilityRuntime;
53 using namespace OHOS::AppExecFwk;
54 using vector_str = std::vector<std::string>;
55
56 namespace OHOS::AbilityRuntime::WantAgent {
57 class WantAgentHelperTest : public testing::Test {
58 public:
WantAgentHelperTest()59 WantAgentHelperTest()
60 {}
~WantAgentHelperTest()61 ~WantAgentHelperTest()
62 {}
63 static void SetUpTestCase(void);
64 static void TearDownTestCase(void);
65 static int callBackCancelListenerConnt;
66 void SetUp();
67 void TearDown();
68 class CancelListenerSon : public CancelListener {
69 public:
70 void OnCancelled(int resultCode) override;
71 };
72 };
73
74 int WantAgentHelperTest::callBackCancelListenerConnt = 0;
75
OnCancelled(int resultCode)76 void WantAgentHelperTest::CancelListenerSon::OnCancelled(int resultCode)
77 {
78 callBackCancelListenerConnt++;
79 }
80
SetUpTestCase(void)81 void WantAgentHelperTest::SetUpTestCase(void)
82 {
83 RemoteNativeToken::SetNativeToken();
84 }
85
TearDownTestCase(void)86 void WantAgentHelperTest::TearDownTestCase(void)
87 {}
88
SetUp(void)89 void WantAgentHelperTest::SetUp(void)
90 {}
91
TearDown(void)92 void WantAgentHelperTest::TearDown(void)
93 {}
94
95 /*
96 * @tc.number : WantAgentHelper_0100
97 * @tc.name : WantAgentHelper Constructors
98 * @tc.desc : 1.WantAgentConstant::Flags::ONE_TIME_FLAG
99 */
100 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0100, Function | MediumTest | Level1)
101 {
102 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
103 std::vector<WantAgentConstant::Flags> flags;
104 flags.emplace_back(WantAgentConstant::Flags::ONE_TIME_FLAG);
105 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0x40000000));
106 }
107
108 /*
109 * @tc.number : WantAgentHelper_0200
110 * @tc.name : WantAgentHelper Constructors
111 * @tc.desc : 1.WantAgentConstant::Flags::NO_BUILD_FLAG
112 */
113 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0200, Function | MediumTest | Level1)
114 {
115 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
116 std::vector<WantAgentConstant::Flags> flags;
117 flags.emplace_back(WantAgentConstant::Flags::NO_BUILD_FLAG);
118 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0x20000000));
119 }
120
121 /*
122 * @tc.number : WantAgentHelper_0300
123 * @tc.name : WantAgentHelper Constructors
124 * @tc.desc : 1.WantAgentConstant::Flags::CANCEL_PRESENT_FLAG
125 */
126 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0300, Function | MediumTest | Level1)
127 {
128 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
129 std::vector<WantAgentConstant::Flags> flags;
130 flags.emplace_back(WantAgentConstant::Flags::CANCEL_PRESENT_FLAG);
131 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0x10000000));
132 }
133
134 /*
135 * @tc.number : WantAgentHelper_0400
136 * @tc.name : WantAgentHelper Constructors
137 * @tc.desc : 1.WantAgentConstant::Flags::UPDATE_PRESENT_FLAG
138 */
139 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0400, Function | MediumTest | Level1)
140 {
141 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
142 std::vector<WantAgentConstant::Flags> flags;
143 flags.emplace_back(WantAgentConstant::Flags::UPDATE_PRESENT_FLAG);
144 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0x8000000));
145 }
146
147 /*
148 * @tc.number : WantAgentHelper_0500
149 * @tc.name : WantAgentHelper Constructors
150 * @tc.desc : 1.WantAgentConstant::Flags::CONSTANT_FLAG
151 */
152 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0500, Function | MediumTest | Level1)
153 {
154 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
155 std::vector<WantAgentConstant::Flags> flags;
156 flags.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
157 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0x4000000));
158 }
159
160 /*
161 * @tc.number : WantAgentHelper_0600
162 * @tc.name : WantAgentHelper Constructors
163 * @tc.desc : 1.WantAgentConstant::Flags::REPLACE_BUNDLE
164 */
165 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0600, Function | MediumTest | Level1)
166 {
167 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
168 std::vector<WantAgentConstant::Flags> flags;
169 flags.emplace_back(WantAgentConstant::Flags::REPLACE_BUNDLE);
170 EXPECT_EQ(
171 wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(FLAG_UPDATE_CURRENT));
172 }
173
174 /*
175 * @tc.number : WantAgentHelper_0700
176 * @tc.name : WantAgentHelper Constructors
177 * @tc.desc : 1.WantAgentConstant::Flags::CONSTANT_FLAG | UPDATE_PRESENT_FLAG | REPLACE_BUNDLE
178 */
179 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0700, Function | MediumTest | Level1)
180 {
181 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
182 std::vector<WantAgentConstant::Flags> flags;
183 flags.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
184 flags.emplace_back(WantAgentConstant::Flags::UPDATE_PRESENT_FLAG);
185 flags.emplace_back(WantAgentConstant::Flags::REPLACE_BUNDLE);
186 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0xc000000));
187 }
188
189 /*
190 * @tc.number : WantAgentHelper_0800
191 * @tc.name : WantAgentHelper GetWantAgent
192 * @tc.desc : 1.GetWantAgent context is nullptr
193 */
194 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0800, Function | MediumTest | Level1)
195 {
196 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
197 WantAgentInfo wantAgentInfo;
198 std::shared_ptr<WantAgent> wantAgent = nullptr;
199 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
200 EXPECT_EQ(wantAgent, nullptr);
201 }
202
203 /*
204 * @tc.number : WantAgentHelper_0900
205 * @tc.name : WantAgentHelper GetWantAgent
206 * @tc.desc : 1.GetWantAgent context is not nullptr
207 * ` 2.wantAgentInfo.wants_ empty
208 */
209 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0900, Function | MediumTest | Level1)
210 {
211 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
212 WantAgentInfo wantAgentInfo;
213 wantAgentInfo.wants_.clear();
214 std::shared_ptr<WantAgent> wantAgent = nullptr;
215 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
216 EXPECT_EQ(wantAgent, nullptr);
217 }
218
219 /*
220 * @tc.number : WantAgentHelper_1000
221 * @tc.name : WantAgentHelper GetWantAgent
222 * @tc.desc : 1.GetWantAgent context is not nullptr
223 * 2.wantAgentInfo.wants_.size() != wantAgentInfo.flags_.size()
224 */
225 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1000, Function | MediumTest | Level1)
226 {
227 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
228 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
229 OHOS::AbilityRuntime::Context::GetApplicationContext();
230 WantAgentInfo wantAgentInfo;
231 std::shared_ptr<Want> want = std::make_shared<Want>();
232 ElementName element("device", "bundleName", "abilityName");
233 want->SetElement(element);
234 wantAgentInfo.wants_.emplace_back(want);
235 wantAgentInfo.flags_.clear();
236 std::shared_ptr<WantAgent> wantAgent = nullptr;
237 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
238 EXPECT_EQ(wantAgent, nullptr);
239 }
240
241 /*
242 * @tc.number : WantAgentHelper_1100
243 * @tc.name : WantAgentHelper GetWantAgent
244 * @tc.desc : 1.GetWantAgent context is not nullptr
245 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
246 * 3.FlagsTransformer return 0
247 */
248 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1100, Function | MediumTest | Level1)
249 {
250 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
251 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
252 OHOS::AbilityRuntime::Context::GetApplicationContext();
253 WantAgentInfo wantAgentInfo;
254 std::shared_ptr<Want> want = std::make_shared<Want>();
255 ElementName element("device", "bundleName", "abilityName");
256 want->SetElement(element);
257 wantAgentInfo.wants_.emplace_back(want);
258 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::REPLACE_BUNDLE);
259 std::shared_ptr<WantAgent> wantAgent = nullptr;
260 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
261 EXPECT_EQ(wantAgent, nullptr);
262 }
263
264 /*
265 * @tc.number : WantAgentHelper_1200
266 * @tc.name : WantAgentHelper GetWantAgent
267 * @tc.desc : 1.GetWantAgent context is not nullptr
268 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
269 * 3.FlagsTransformer return ok
270 * 4.Type is WantAgentConstant::OperationType::START_ABILITY
271 */
272 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1200, Function | MediumTest | Level1)
273 {
274 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
275 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
276 AbilityRuntime::ApplicationContext::GetInstance();
277 std::shared_ptr<Want> want = std::make_shared<Want>();
278 ElementName element("device", "bundleName", "abilityName");
279 want->SetElement(element);
280 WantAgentInfo wantAgentInfo;
281 wantAgentInfo.wants_.emplace_back(want);
282 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
283 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
284 wantAgentInfo.requestCode_ = 10;
285 std::shared_ptr<WantAgent> wantAgent = nullptr;
286 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
287 EXPECT_EQ(wantAgent, nullptr);
288 }
289
290 /*
291 * @tc.number : WantAgentHelper_1300
292 * @tc.name : WantAgentHelper GetWantAgent
293 * @tc.desc : 1.GetWantAgent context is not nullptr
294 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
295 * 3.FlagsTransformer return ok
296 * 4.Type is WantAgentConstant::OperationType::START_ABILITIES
297 */
298 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1300, Function | MediumTest | Level1)
299 {
300 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
301 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
302 AbilityRuntime::ApplicationContext::GetInstance();
303 std::shared_ptr<Want> want = std::make_shared<Want>();
304 ElementName element("device", "bundleName", "abilityName");
305 want->SetElement(element);
306 WantAgentInfo wantAgentInfo;
307 wantAgentInfo.wants_.emplace_back(want);
308 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
309 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITIES;
310 wantAgentInfo.requestCode_ = 10;
311 std::shared_ptr<WantAgent> wantAgent = nullptr;
312 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
313 EXPECT_EQ(wantAgent, nullptr);
314 }
315
316 /*
317 * @tc.number : WantAgentHelper_1400
318 * @tc.name : WantAgentHelper GetWantAgent
319 * @tc.desc : 1.GetWantAgent context is not nullptr
320 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
321 * 3.FlagsTransformer return ok
322 * 4.Type is WantAgentConstant::OperationType::START_SERVICE
323 */
324 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1400, Function | MediumTest | Level1)
325 {
326 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
327 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
328 AbilityRuntime::ApplicationContext::GetInstance();
329 std::shared_ptr<Want> want = std::make_shared<Want>();
330 ElementName element("device", "bundleName", "abilityName");
331 want->SetElement(element);
332 WantAgentInfo wantAgentInfo;
333 wantAgentInfo.wants_.emplace_back(want);
334 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
335 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_SERVICE;
336 wantAgentInfo.requestCode_ = 10;
337 std::shared_ptr<WantAgent> wantAgent = nullptr;
338 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
339 EXPECT_EQ(wantAgent, nullptr);
340 }
341
342 /*
343 * @tc.number : WantAgentHelper_1500
344 * @tc.name : WantAgentHelper GetWantAgent
345 * @tc.desc : 1.GetWantAgent context is not nullptr
346 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
347 * 3.FlagsTransformer return ok
348 * 4.Type is WantAgentConstant::OperationType::START_FOREGROUND_SERVICE
349 */
350 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1500, Function | MediumTest | Level1)
351 {
352 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
353 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
354 AbilityRuntime::ApplicationContext::GetInstance();
355 std::shared_ptr<Want> want = std::make_shared<Want>();
356 ElementName element("device", "bundleName", "abilityName");
357 want->SetElement(element);
358 WantAgentInfo wantAgentInfo;
359 wantAgentInfo.wants_.emplace_back(want);
360 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
361 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
362 wantAgentInfo.requestCode_ = 10;
363 std::shared_ptr<WantAgent> wantAgent = nullptr;
364 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
365 EXPECT_EQ(wantAgent, nullptr);
366 }
367
368 /*
369 * @tc.number : WantAgentHelper_1600
370 * @tc.name : WantAgentHelper GetWantAgent
371 * @tc.desc : 1.GetWantAgent context is not nullptr
372 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
373 * 3.FlagsTransformer return ok
374 * 4.Type is WantAgentConstant::OperationType::START_FOREGROUND_SERVICE
375 */
376 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1600, Function | MediumTest | Level1)
377 {
378 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
379 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
380 AbilityRuntime::ApplicationContext::GetInstance();
381 std::shared_ptr<Want> want = std::make_shared<Want>();
382 ElementName element("device", "bundleName", "abilityName");
383 want->SetElement(element);
384 WantAgentInfo wantAgentInfo;
385 wantAgentInfo.wants_.emplace_back(want);
386 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
387 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::SEND_COMMON_EVENT;
388 wantAgentInfo.requestCode_ = 10;
389 std::shared_ptr<WantAgent> wantAgent = nullptr;
390 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
391 EXPECT_EQ(wantAgent, nullptr);
392 }
393
394 /*
395 * @tc.number : WantAgentHelper_1700
396 * @tc.name : WantAgentHelper GetWantAgent
397 * @tc.desc : 1.GetWantAgent context is not nullptr
398 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
399 * 3.FlagsTransformer return ok
400 * 4.Type is 100
401 */
402 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1700, Function | MediumTest | Level1)
403 {
404 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
405 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
406 AbilityRuntime::ApplicationContext::GetInstance();
407 std::shared_ptr<Want> want = std::make_shared<Want>();
408 ElementName element("device", "bundleName", "abilityName");
409 want->SetElement(element);
410 WantAgentInfo wantAgentInfo;
411 wantAgentInfo.wants_.emplace_back(want);
412 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
413 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
414 wantAgentInfo.requestCode_ = 10;
415 std::shared_ptr<WantAgent> wantAgent = nullptr;
416 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
417 EXPECT_EQ(wantAgent, nullptr);
418 }
419
420 /*
421 * @tc.number : WantAgentHelper_1800
422 * @tc.name : WantAgentHelper GetWantAgent(const WantAgentInfo ¶msInfo)
423 * @tc.desc : 1.wantAgentInfo.wants_.size() == 0
424 */
425 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1800, Function | MediumTest | Level1)
426 {
427 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
428 WantAgentInfo wantAgentInfo;
429 wantAgentInfo.wants_.clear();
430 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
431 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
432 wantAgentInfo.requestCode_ = 10;
433 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
434 EXPECT_EQ(wantAgent, nullptr);
435 }
436
437 /*
438 * @tc.number : WantAgentHelper_1900
439 * @tc.name : WantAgentHelper GetWantAgent(const WantAgentInfo ¶msInfo)
440 * @tc.desc : 1.wantAgentInfo.wants_ not empty
441 * 2.wantAgentInfo.wants_.size() != wantAgentInfo.flags_.size()
442 */
443 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1900, Function | MediumTest | Level1)
444 {
445 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
446 std::shared_ptr<Want> want = std::make_shared<Want>();
447 ElementName element("device", "bundleName", "abilityName");
448 want->SetElement(element);
449 WantAgentInfo wantAgentInfo;
450 wantAgentInfo.wants_.emplace_back(want);
451 wantAgentInfo.flags_.clear();
452 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
453 wantAgentInfo.requestCode_ = 10;
454 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
455 EXPECT_NE(wantAgent, nullptr);
456 }
457
458 /*
459 * @tc.number : WantAgentHelper_2000
460 * @tc.name : WantAgentHelper GetWantAgent(const WantAgentInfo ¶msInfo)
461 * @tc.desc : 1.wantAgentInfo.wants_ not empty
462 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
463 * 3.wantAgentInfo.wants_[0] is nullptr
464 */
465 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2000, Function | MediumTest | Level1)
466 {
467 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
468 std::shared_ptr<Want> want = std::make_shared<Want>();
469 ElementName element("device", "bundleName", "abilityName");
470 want->SetElement(element);
471 WantAgentInfo wantAgentInfo;
472 wantAgentInfo.wants_.emplace_back(nullptr);
473 wantAgentInfo.wants_.emplace_back(want);
474 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
475 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
476 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
477 wantAgentInfo.requestCode_ = 10;
478 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
479 EXPECT_EQ(wantAgent, nullptr);
480 }
481
482 /*
483 * @tc.number : WantAgentHelper_2100
484 * @tc.name : WantAgentHelper GetWantAgent(const WantAgentInfo ¶msInfo)
485 * @tc.desc : 1.wantAgentInfo.wants_ not empty
486 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
487 * 3.wantAgentInfo.wants_[0] is not nullptr
488 * 4.wantAgentInfo.extraInfo_ is not nullptr
489 */
490 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2100, Function | MediumTest | Level1)
491 {
492 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
493 std::shared_ptr<Want> want = std::make_shared<Want>();
494 ElementName element("device", "bundleName", "abilityName");
495 want->SetElement(element);
496 WantAgentInfo wantAgentInfo;
497 wantAgentInfo.wants_.emplace_back(want);
498 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
499 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
500 wantAgentInfo.requestCode_ = 10;
501 bool value = true;
502 std::string key = "key";
503 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
504 wParams->SetParam(key, Boolean::Box(value));
505 wantAgentInfo.extraInfo_ = wParams;
506 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
507 EXPECT_NE(wantAgent, nullptr);
508 }
509
510 /*
511 * @tc.number : WantAgentHelper_2200
512 * @tc.name : WantAgentHelper GetWantAgent(const WantAgentInfo ¶msInfo)
513 * @tc.desc : 1.wantAgentInfo.wants_ not empty
514 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
515 * 3.wantAgentInfo.wants_[0] is not nullptr
516 * 4.wantAgentInfo.extraInfo_ is nullptr
517 */
518 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2200, Function | MediumTest | Level1)
519 {
520 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
521 std::shared_ptr<Want> want = std::make_shared<Want>();
522 ElementName element("device", "bundleName", "abilityName");
523 want->SetElement(element);
524 WantAgentInfo wantAgentInfo;
525 wantAgentInfo.wants_.emplace_back(want);
526 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
527 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
528 wantAgentInfo.requestCode_ = 10;
529 wantAgentInfo.extraInfo_ = nullptr;
530 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
531 EXPECT_NE(wantAgent, nullptr);
532 }
533
534 /*
535 * @tc.number : WantAgentHelper_2300
536 * @tc.name : WantAgentHelper GetType
537 * @tc.desc : 1.agent is not nullptr
538 */
539 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2300, Function | MediumTest | Level1)
540 {
541 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
542 WantAgentInfo wantAgentInfo;
543 std::shared_ptr<WantAgent> wantAgent = nullptr;
544 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
545 auto type = wantAgentHelper->GetType(wantAgent);
546 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
547 }
548
549 /*
550 * @tc.number : WantAgentHelper_2400
551 * @tc.name : WantAgentHelper GetType
552 * @tc.desc : 1.agent is not nullptr
553 */
554 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2400, Function | MediumTest | Level1)
555 {
556 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
557 std::shared_ptr<WantAgent> wantAgent(nullptr);
558 auto type = wantAgentHelper->GetType(wantAgent);
559 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
560 }
561
562 /*
563 * @tc.number : WantAgentHelper_2500
564 * @tc.name : WantAgentHelper GetType
565 * @tc.desc : 1.agent is not nullptr,PendingWant is nullptr
566 */
567 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2500, Function | MediumTest | Level1)
568 {
569 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
570 std::shared_ptr<PendingWant> pendingWant(nullptr);
571 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
572 auto type = wantAgentHelper->GetType(wantAgent);
573 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
574 }
575
576 /*
577 * @tc.number : WantAgentHelper_2600
578 * @tc.name : WantAgentHelper JudgeEquality
579 * @tc.desc : 1.JudgeEquality
580 */
581 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2600, Function | MediumTest | Level1)
582 {
583 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
584 std::shared_ptr<WantAgent> wantAgent(nullptr);
585 std::shared_ptr<WantAgent> wantAgent2(nullptr);
586 ErrCode isEqual = wantAgentHelper->IsEquals(wantAgent, wantAgent2);
587 EXPECT_EQ(isEqual, ERR_OK);
588 }
589
590 /*
591 * @tc.number : WantAgentHelper_2700
592 * @tc.name : WantAgentHelper JudgeEquality
593 * @tc.desc : 1.JudgeEquality,Judge whether it is equal or not
594 */
595 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2700, Function | MediumTest | Level1)
596 {
597 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
598
599 // pendingwant
600 int requestCode = 10;
601 std::shared_ptr<Want> want = std::make_shared<Want>();
602 ElementName element("device", "bundleName", "abilityName");
603 want->SetElement(element);
604 unsigned int flags = 1;
605 flags |= FLAG_ONE_SHOT;
606 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
607 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
608 AbilityRuntime::ApplicationContext::GetInstance();
609 std::shared_ptr<PendingWant> pendingWant = nullptr;
610 PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
611
612 // pendingwant2
613 int requestCode2 = 11;
614 std::shared_ptr<Want> want2 = std::make_shared<Want>();
615 ElementName element2("device", "bundle", "ability");
616 want2->SetElement(element2);
617 std::shared_ptr<PendingWant> pendingWant2 = nullptr;
618 PendingWant::BuildServicePendingWant(context, requestCode2, want2, flags, type, pendingWant2);
619
620 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
621 std::shared_ptr<WantAgent> wantAgent2 = std::make_shared<WantAgent>(pendingWant2);
622 ErrCode isEqual = wantAgentHelper->IsEquals(wantAgent, wantAgent2);
623 EXPECT_NE(isEqual, ERR_OK);
624 }
625
626 /*
627 * @tc.number : WantAgentHelper_2800
628 * @tc.name : WantAgentHelper JudgeEquality
629 * @tc.desc : 1.JudgeEquality,Judge whether it is equal or not
630 */
631 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2800, Function | MediumTest | Level1)
632 {
633 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
634
635 int requestCode = 10;
636 std::shared_ptr<Want> want = std::make_shared<Want>();
637 ElementName element("device", "bundleName", "abilityName");
638 want->SetElement(element);
639 unsigned int flags = 1;
640 flags |= FLAG_ONE_SHOT;
641 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
642 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
643 AbilityRuntime::ApplicationContext::GetInstance();
644 std::shared_ptr<PendingWant> pendingWant = nullptr;
645 PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
646
647 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
648 std::shared_ptr<WantAgent> wantAgent2 = std::make_shared<WantAgent>(pendingWant);
649 ErrCode isEqual = wantAgentHelper->IsEquals(wantAgent, wantAgent2);
650 EXPECT_EQ(isEqual, ERR_OK);
651 }
652
653 /*
654 * @tc.number : WantAgentHelper_2900
655 * @tc.name : WantAgentHelper JudgeEquality
656 * @tc.desc : 1.JudgeEquality,Judge whether it is equal or not
657 */
658 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2900, Function | MediumTest | Level1)
659 {
660 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
661
662 int requestCode = 10;
663 std::shared_ptr<Want> want = std::make_shared<Want>();
664 ElementName element("device", "bundleName", "abilityName");
665 want->SetElement(element);
666 unsigned int flags = 1;
667 flags |= FLAG_ONE_SHOT;
668 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
669 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
670 AbilityRuntime::ApplicationContext::GetInstance();
671 std::shared_ptr<PendingWant> pendingWant = nullptr;
672 PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
673
674 std::shared_ptr<PendingWant> pendingWant2(nullptr);
675 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
676 std::shared_ptr<WantAgent> wantAgent2 = std::make_shared<WantAgent>(pendingWant2);
677 ErrCode isEqual = wantAgentHelper->IsEquals(wantAgent, wantAgent2);
678 EXPECT_NE(isEqual, ERR_OK);
679 }
680
681 /*
682 * @tc.number : WantAgentHelper_3000
683 * @tc.name : WantAgentHelper GetBundleName
684 * @tc.desc : 1.GetBundleName WantAgent is nullptr
685 */
686 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3000, Function | MediumTest | Level1)
687 {
688 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
689 std::shared_ptr<WantAgent> wantAgent(nullptr);
690 std::string bundleName = "";
691 wantAgentHelper->GetBundleName(wantAgent, bundleName);
692 EXPECT_EQ(bundleName, "");
693 }
694
695 /*
696 * @tc.number : WantAgentHelper_3100
697 * @tc.name : WantAgentHelper GetBundleName
698 * @tc.desc : 1.GetBundleName WantAgent.PendingWant.target is nullptr
699 */
700 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3100, Function | MediumTest | Level1)
701 {
702 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
703 std::shared_ptr<PendingWant> pendingWant(nullptr);
704 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
705 std::string bundleName = "";
706 wantAgentHelper->GetBundleName(wantAgent, bundleName);
707 EXPECT_EQ(bundleName, "");
708 }
709
710 /*
711 * @tc.number : WantAgentHelper_3200
712 * @tc.name : WantAgentHelper GetUid
713 * @tc.desc : 1.GetUid WantAgent is nullptr
714 */
715 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3200, Function | MediumTest | Level1)
716 {
717 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
718 EXPECT_NE(wantAgentHelper, nullptr);
719 std::shared_ptr<WantAgent> wantAgent(nullptr);
720 int32_t uid = -1;
721 wantAgentHelper->GetUid(wantAgent, uid);
722 }
723
724 /*
725 * @tc.number : WantAgentHelper_3300
726 * @tc.name : WantAgentHelper GetUid
727 * @tc.desc : 1.GetUid WantAgent.PendingWant.target is nullptr
728 */
729 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3300, Function | MediumTest | Level1)
730 {
731 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
732 EXPECT_NE(wantAgentHelper, nullptr);
733 std::shared_ptr<PendingWant> pendingWant(nullptr);
734 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
735 int32_t uid = -1;
736 wantAgentHelper->GetUid(wantAgent, uid);
737 }
738
739 /*
740 * @tc.number : WantAgentHelper_3400
741 * @tc.name : WantAgentHelper GetWant
742 * @tc.desc : 1.GetWant WantAgent is nullptr
743 */
744 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3400, Function | MediumTest | Level1)
745 {
746 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
747 std::shared_ptr<WantAgent> wantAgent(nullptr);
748 auto want = wantAgentHelper->GetWant(wantAgent);
749 EXPECT_EQ(want, nullptr);
750 }
751
752 /*
753 * @tc.number : WantAgentHelper_3500
754 * @tc.name : WantAgentHelper GetWant
755 * @tc.desc : 1.GetWant WantAgent.PendingWant.target is nullptr
756 */
757 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3500, Function | MediumTest | Level1)
758 {
759 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
760 std::shared_ptr<PendingWant> pendingWant(nullptr);
761 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
762 auto want = wantAgentHelper->GetWant(wantAgent);
763 EXPECT_EQ(want, nullptr);
764 }
765
766 /*
767 * @tc.number : WantAgentHelper_3600
768 * @tc.name : WantAgentHelper ParseFlags
769 * @tc.desc : 1.ParseFlags Check ParseFlags
770 */
771 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3600, Function | MediumTest | Level1)
772 {
773 std::vector<WantAgentConstant::Flags> flagsVec;
774 nlohmann::json jsonObject;
775
776 jsonObject["flags"] = -1;
777 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
778 EXPECT_EQ(flagsVec.size(), 0);
779
780 jsonObject.clear();
781 jsonObject["flags"] = 1111000000;
782 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
783 std::vector<WantAgentConstant::Flags>::iterator oneTimeIt = std::find(flagsVec.begin(), flagsVec.end(),
784 WantAgentConstant::Flags::ONE_TIME_FLAG);
785 EXPECT_EQ(oneTimeIt != flagsVec.end(), true);
786
787 jsonObject.clear();
788 jsonObject["flags"] = 111100000000000;
789 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
790 std::vector<WantAgentConstant::Flags>::iterator cancelPresentIt = std::find(flagsVec.begin(), flagsVec.end(),
791 WantAgentConstant::Flags::CANCEL_PRESENT_FLAG);
792 EXPECT_EQ(cancelPresentIt != flagsVec.end(), true);
793
794 jsonObject.clear();
795 jsonObject["flags"] = 111100000000000;
796 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
797 std::vector<WantAgentConstant::Flags>::iterator updateResentIt = std::find(flagsVec.begin(), flagsVec.end(),
798 WantAgentConstant::Flags::UPDATE_PRESENT_FLAG);
799 EXPECT_EQ(updateResentIt != flagsVec.end(), true);
800
801 jsonObject.clear();
802 jsonObject["flags"] = 111100000000000;
803 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
804 std::vector<WantAgentConstant::Flags>::iterator constantIt = std::find(flagsVec.begin(), flagsVec.end(),
805 WantAgentConstant::Flags::CONSTANT_FLAG);
806 EXPECT_EQ(constantIt != flagsVec.end(), true);
807
808 jsonObject.clear();
809 jsonObject["flags"] = 1000000000;
810 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
811 std::vector<WantAgentConstant::Flags>::iterator noBuildIt = std::find(flagsVec.begin(), flagsVec.end(),
812 WantAgentConstant::Flags::NO_BUILD_FLAG);
813 EXPECT_EQ(noBuildIt != flagsVec.end(), true);
814 }
815
816 /*
817 * @tc.number : WantAgentHelper_3700
818 * @tc.name : WantAgentHelper GetType
819 * @tc.desc : 1.agent is nullptr
820 */
821 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3700, Function | MediumTest | Level1)
822 {
823 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
824 std::shared_ptr<WantAgent> wantAgent(nullptr);
825 int32_t type = static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE);
826 EXPECT_EQ(wantAgentHelper->GetType(wantAgent, type), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
827 EXPECT_EQ(type, static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE));
828 }
829
830 /*
831 * @tc.number : WantAgentHelper_3800
832 * @tc.name : WantAgentHelper GetType
833 * @tc.desc : 1.agent is not nullptr,PendingWant is nullptr
834 */
835 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3800, Function | MediumTest | Level1)
836 {
837 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
838 std::shared_ptr<PendingWant> pendingWant(nullptr);
839 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
840 auto type = static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE);
841 EXPECT_EQ(wantAgentHelper->GetType(wantAgent, type), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
842 EXPECT_EQ(type, static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE));
843 }
844
845 /*
846 * @tc.number : WantAgentHelper_3900
847 * @tc.name : WantAgentHelper GetType
848 * @tc.desc : 1.agent is not nullptr, PendingWant is not nullptr
849 */
850 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3900, Function | MediumTest | Level1)
851 {
852 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
853 sptr<AAFwk::IWantSender> target(nullptr);
854 std::shared_ptr<PendingWant> pendingWant = std::make_shared<PendingWant>(target);
855 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
856 auto type = static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE);
857 EXPECT_EQ(wantAgentHelper->GetType(wantAgent, type), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
858 EXPECT_EQ(type, static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE));
859 }
860
861 /*
862 * @tc.number : WantAgentHelper_4000
863 * @tc.name : WantAgentHelper GetWant
864 * @tc.desc : 1.GetWant WantAgent is nullptr
865 */
866 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4000, Function | MediumTest | Level1)
867 {
868 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
869 std::shared_ptr<WantAgent> wantAgent(nullptr);
870 std::shared_ptr<AAFwk::Want> want(nullptr);
871 EXPECT_EQ(wantAgentHelper->GetWant(wantAgent, want), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
872 EXPECT_EQ(want, nullptr);
873 }
874
875 /*
876 * @tc.number : WantAgentHelper_4100
877 * @tc.name : WantAgentHelper GetWant
878 * @tc.desc : 1.GetWant WantAgent.PendingWant is nullptr
879 */
880 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4100, Function | MediumTest | Level1)
881 {
882 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
883 std::shared_ptr<PendingWant> pendingWant(nullptr);
884 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
885 std::shared_ptr<AAFwk::Want> want(nullptr);
886 EXPECT_EQ(wantAgentHelper->GetWant(wantAgent, want), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
887 EXPECT_EQ(want, nullptr);
888 }
889
890 /*
891 * @tc.number : WantAgentHelper_4200
892 * @tc.name : WantAgentHelper GetWant
893 * @tc.desc : 1.GetWant WantAgent and WantAgent.PendingWant is not nullptr
894 */
895 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4200, Function | MediumTest | Level1)
896 {
897 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
898 sptr<AAFwk::IWantSender> target(nullptr);
899 std::shared_ptr<PendingWant> pendingWant = std::make_shared<PendingWant>(target);
900 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
901 std::shared_ptr<AAFwk::Want> want(nullptr);
902 EXPECT_EQ(wantAgentHelper->GetWant(wantAgent, want), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
903 EXPECT_EQ(want, nullptr);
904 }
905
906 /*
907 * @tc.number : WantAgentHelper_4500
908 * @tc.name : WantAgentHelper RegisterCancelListener
909 * @tc.desc : 1.RegisterCancelListener when agent is null.
910 */
911 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4500, Function | MediumTest | Level1)
912 {
913 GTEST_LOG_(INFO) << "WantAgentHelper::RegisterCancelListener start";
914
915 std::shared_ptr<CancelListener> cancelListener1 = std::make_shared<CancelListenerSon>();
916 std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
917
918 WantAgentHelper::RegisterCancelListener(cancelListener1, nullptr);
919 WantAgentHelper::RegisterCancelListener(cancelListener2, nullptr);
920
921 GTEST_LOG_(INFO) << "WantAgentHelper::RegisterCancelListener end";
922 }
923
924 /*
925 * @tc.number : WantAgentHelper_4600
926 * @tc.name : WantAgentHelper RegisterCancelListener
927 * @tc.desc : 2.RegisterCancelListener normal test
928 */
929 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4600, Function | MediumTest | Level1)
930 {
931 GTEST_LOG_(INFO) << "WantAgentHelper::RegisterCancelListener start";
932
933 int requestCode = 10;
934 std::shared_ptr<Want> want = std::make_shared<Want>();
935 ElementName element("device", "bundleName", "abilityName");
936 want->SetElement(element);
937 unsigned int flags = 1;
938 flags |= FLAG_ONE_SHOT;
939 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
940 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
941 AbilityRuntime::ApplicationContext::GetInstance();
942 std::shared_ptr<PendingWant> pendingWant = nullptr;
943 PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
944 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
945
946 std::shared_ptr<CancelListener> cancelListener = std::make_shared<CancelListenerSon>();
947
948 WantAgentHelper::RegisterCancelListener(cancelListener, wantAgent);
949
950 EXPECT_EQ(static_cast<int>(wantAgent->GetPendingWant()->cancelListeners_.size()), 1);
951
952 GTEST_LOG_(INFO) << "WantAgentHelper::RegisterCancelListener end";
953 }
954
955 /*
956 * @tc.number : WantAgentHelper_4700
957 * @tc.name : WantAgentHelper UnregisterCancelListener
958 * @tc.desc : 1.UnregisterCancelListener when agent is nullptr.
959 */
960 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4700, Function | MediumTest | Level1)
961 {
962 GTEST_LOG_(INFO) << "WantAgentHelper::UnregisterCancelListener start";
963
964 std::shared_ptr<CancelListener> cancelListener1 = std::make_shared<CancelListenerSon>();
965 std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
966 WantAgentHelper::UnregisterCancelListener(cancelListener1, nullptr);
967 WantAgentHelper::UnregisterCancelListener(cancelListener2, nullptr);
968
969 GTEST_LOG_(INFO) << "WantAgentHelper::UnregisterCancelListener end";
970 }
971
972 /*
973 * @tc.number : WantAgentHelper_4800
974 * @tc.name : WantAgentHelper UnregisterCancelListener
975 * @tc.desc : 2.UnregisterCancelListener normal test.
976 */
977 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4800, Function | MediumTest | Level1)
978 {
979 GTEST_LOG_(INFO) << "WantAgentHelper::UnregisterCancelListener start";
980
981 int requestCode = 10;
982 std::shared_ptr<Want> want = std::make_shared<Want>();
983 ElementName element("device", "bundleName", "abilityName");
984 want->SetElement(element);
985 unsigned int flags = 1;
986 flags |= FLAG_ONE_SHOT;
987 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
988 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
989 AbilityRuntime::ApplicationContext::GetInstance();
990 std::shared_ptr<PendingWant> pendingWant = nullptr;
991 PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
992 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
993
994 std::shared_ptr<CancelListener> cancelListener = std::make_shared<CancelListenerSon>();
995
996 WantAgentHelper::RegisterCancelListener(cancelListener, wantAgent);
997 EXPECT_EQ(static_cast<int>(wantAgent->GetPendingWant()->cancelListeners_.size()), 1);
998
999 WantAgentHelper::UnregisterCancelListener(cancelListener, wantAgent);
1000 EXPECT_EQ(static_cast<int>(wantAgent->GetPendingWant()->cancelListeners_.size()), 0);
1001
1002 GTEST_LOG_(INFO) << "WantAgentHelper::UnregisterCancelListener end";
1003 }
1004
1005 /*
1006 * @tc.number : WantAgentHelper_4900
1007 * @tc.name : WantAgentHelper TriggerWantAgent
1008 * @tc.desc : Test TriggerWantAgent when agent is nullptr.
1009 */
1010 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4900, Function | MediumTest | Level1)
1011 {
1012 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent start";
1013
1014 std::shared_ptr<CompletedCallback> callback;
1015 TriggerInfo paramsInfo;
1016 sptr<CompletedDispatcher> completedData;
1017 WantAgentHelper::TriggerWantAgent(nullptr, callback, paramsInfo, completedData, nullptr);
1018
1019 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent end";
1020 }
1021
1022 /*
1023 * @tc.number : WantAgentHelper_5000
1024 * @tc.name : WantAgentHelper TriggerWantAgent
1025 * @tc.desc : Test TriggerWantAgent when callback is nullptr.
1026 */
1027 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5000, Function | MediumTest | Level1)
1028 {
1029 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent start";
1030
1031 std::shared_ptr<WantAgent> wantAgent(nullptr);
1032 TriggerInfo paramsInfo;
1033 sptr<CompletedDispatcher> completedData;
1034 WantAgentHelper::TriggerWantAgent(wantAgent, nullptr, paramsInfo, completedData, nullptr);
1035
1036 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent end";
1037 }
1038
1039 /*
1040 * @tc.number : WantAgentHelper_5100
1041 * @tc.name : WantAgentHelper TriggerWantAgent
1042 * @tc.desc : Test TriggerWantAgent.
1043 */
1044 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5100, Function | MediumTest | Level1)
1045 {
1046 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent start";
1047
1048 std::shared_ptr<WantAgent> wantAgent(nullptr);
1049 std::shared_ptr<CompletedCallback> callback;
1050 TriggerInfo paramsInfo;
1051 sptr<CompletedDispatcher> completedData;
1052 WantAgentHelper::TriggerWantAgent(wantAgent, callback, paramsInfo, completedData, nullptr);
1053
1054 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent end";
1055 }
1056
1057 /*
1058 * @tc.number : WantAgentHelper_5200
1059 * @tc.name : WantAgentHelper ToString
1060 * @tc.desc : Test ToString.
1061 */
1062 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5200, Function | MediumTest | Level1)
1063 {
1064 GTEST_LOG_(INFO) << "WantAgentHelper::ToString start";
1065 std::shared_ptr<WantAgent> agent(nullptr);
1066 auto result = WantAgentHelper::ToString(agent);
1067 EXPECT_TRUE(result == "");
1068 GTEST_LOG_(INFO) << "WantAgentHelper::ToString end";
1069 }
1070
1071 /*
1072 * @tc.number : WantAgentHelper_5300
1073 * @tc.name : WantAgentHelper FromString
1074 * @tc.desc : Test FromString.
1075 */
1076 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5300, Function | MediumTest | Level1)
1077 {
1078 GTEST_LOG_(INFO) << "WantAgentHelper::FromString start";
1079 std::string jsonString;
1080 auto result = WantAgentHelper::FromString(jsonString);
1081 EXPECT_TRUE(result == nullptr);
1082 GTEST_LOG_(INFO) << "WantAgentHelper::FromString end";
1083 }
1084
1085 /*
1086 * @tc.number : WantAgentHelper_5400
1087 * @tc.name : WantAgentHelper Cancel by flags FLAG_ONE_SHOT
1088 * @tc.desc : 1.wantAgentInfo.wants_ not empty
1089 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
1090 * 3.wantAgentInfo.wants_[0] is not nullptr
1091 * 4.wantAgentInfo.extraInfo_ is not nullptr
1092 */
1093 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5400, Function | MediumTest | Level1)
1094 {
1095 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
1096 std::shared_ptr<Want> want = std::make_shared<Want>();
1097 ElementName element("device", "bundleName", "abilityName");
1098 want->SetElement(element);
1099 WantAgentInfo wantAgentInfo;
1100 wantAgentInfo.wants_.emplace_back(want);
1101 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::ONE_TIME_FLAG);
1102 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
1103 wantAgentInfo.requestCode_ = 10;
1104 bool value = true;
1105 std::string key = "key";
1106 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1107 wParams->SetParam(key, Boolean::Box(value));
1108 wantAgentInfo.extraInfo_ = wParams;
1109 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
1110 EXPECT_NE(wantAgent, nullptr);
1111 auto type = wantAgentHelper->GetType(wantAgent);
1112 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1113
1114 WantAgentHelper::Cancel(wantAgent, FLAG_UPDATE_CURRENT);
1115 type = WantAgentHelper::GetType(wantAgent);
1116 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1117
1118 WantAgentHelper::Cancel(wantAgent, FLAG_ONE_SHOT);
1119 type = WantAgentHelper::GetType(wantAgent);
1120 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1121 }
1122
1123 /*
1124 * @tc.number : WantAgentHelper_5500
1125 * @tc.name : WantAgentHelper Cancel again
1126 * @tc.desc : 1.wantAgentInfo.wants_ not empty
1127 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
1128 * 3.wantAgentInfo.wants_[0] is not nullptr
1129 * 4.wantAgentInfo.extraInfo_ is not nullptr
1130 */
1131 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5500, Function | MediumTest | Level1)
1132 {
1133 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
1134 std::shared_ptr<Want> want = std::make_shared<Want>();
1135 ElementName element("device", "bundleName", "abilityName");
1136 want->SetElement(element);
1137 WantAgentInfo wantAgentInfo;
1138 wantAgentInfo.wants_.emplace_back(want);
1139 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::ONE_TIME_FLAG);
1140 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
1141 wantAgentInfo.requestCode_ = 10;
1142 bool value = true;
1143 std::string key = "key";
1144 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1145 wParams->SetParam(key, Boolean::Box(value));
1146 wantAgentInfo.extraInfo_ = wParams;
1147 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
1148 EXPECT_NE(wantAgent, nullptr);
1149 auto type = wantAgentHelper->GetType(wantAgent);
1150 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1151
1152 WantAgentHelper::Cancel(wantAgent);
1153 type = WantAgentHelper::GetType(wantAgent);
1154 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1155
1156 WantAgentHelper::Cancel(wantAgent, FLAG_ONE_SHOT);
1157 type = WantAgentHelper::GetType(wantAgent);
1158 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1159 }
1160
1161 /*
1162 * @tc.number : WantAgentHelper_5600
1163 * @tc.name : WantAgentHelper Cancel by flags FLAG_UPDATE_CURRENT
1164 * @tc.desc : 1.wantAgentInfo.wants_ not empty
1165 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
1166 * 3.wantAgentInfo.wants_[0] is not nullptr
1167 * 4.wantAgentInfo.extraInfo_ is not nullptr
1168 */
1169 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5600, Function | MediumTest | Level1)
1170 {
1171 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
1172 std::shared_ptr<Want> want = std::make_shared<Want>();
1173 ElementName element("device", "bundleName", "abilityName");
1174 want->SetElement(element);
1175 WantAgentInfo wantAgentInfo;
1176 wantAgentInfo.wants_.emplace_back(want);
1177 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
1178 wantAgentInfo.requestCode_ = 10;
1179 bool value = true;
1180 std::string key = "key";
1181 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1182 wParams->SetParam(key, Boolean::Box(value));
1183 wantAgentInfo.extraInfo_ = wParams;
1184 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
1185 EXPECT_NE(wantAgent, nullptr);
1186 auto type = wantAgentHelper->GetType(wantAgent);
1187 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1188
1189 WantAgentHelper::Cancel(wantAgent, FLAG_ONE_SHOT);
1190 type = WantAgentHelper::GetType(wantAgent);
1191 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1192
1193 WantAgentHelper::Cancel(wantAgent, FLAG_UPDATE_CURRENT);
1194 type = WantAgentHelper::GetType(wantAgent);
1195 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1196 }
1197
1198 /*
1199 * @tc.number : WantAgentHelper_5700
1200 * @tc.name : WantAgentHelper Cancel by flags FLAG_ONE_SHOT|FLAG_ALLOW_CANCEL
1201 * @tc.desc : 1.wantAgentInfo.wants_ not empty
1202 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
1203 * 3.wantAgentInfo.wants_[0] is not nullptr
1204 * 4.wantAgentInfo.extraInfo_ is not nullptr
1205 */
1206 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5700, Function | MediumTest | Level1)
1207 {
1208 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
1209 std::shared_ptr<Want> want = std::make_shared<Want>();
1210 ElementName element("device", "bundleName", "abilityName");
1211 want->SetElement(element);
1212 WantAgentInfo wantAgentInfo;
1213 wantAgentInfo.wants_.emplace_back(want);
1214 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::ALLOW_CANCEL_FLAG);
1215 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
1216 wantAgentInfo.requestCode_ = 20;
1217 bool value = true;
1218 std::string key = "key";
1219 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1220 wParams->SetParam(key, Boolean::Box(value));
1221 wantAgentInfo.extraInfo_ = wParams;
1222 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
1223 EXPECT_NE(wantAgent, nullptr);
1224 auto type = wantAgentHelper->GetType(wantAgent);
1225 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1226
1227 WantAgentHelper::Cancel(wantAgent, FLAG_UPDATE_CURRENT);
1228 type = WantAgentHelper::GetType(wantAgent);
1229 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1230
1231 WantAgentHelper::Cancel(wantAgent, FLAG_ONE_SHOT);
1232 type = WantAgentHelper::GetType(wantAgent);
1233 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1234
1235 WantAgentHelper::Cancel(wantAgent, FLAG_ONE_SHOT|FLAG_ALLOW_CANCEL);
1236 type = WantAgentHelper::GetType(wantAgent);
1237 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1238 }
1239
1240 /*
1241 * @tc.number : WantAgentHelper_5800
1242 * @tc.name : WantAgentHelper Cancel success after remove death recipient
1243 * @tc.desc : RemoveDeathRecipient normal test
1244 */
1245 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5800, Function | MediumTest | Level1)
1246 {
1247 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
1248 std::shared_ptr<Want> want = std::make_shared<Want>();
1249 ElementName element("device", "bundleName", "abilityName");
1250 want->SetElement(element);
1251 WantAgentInfo wantAgentInfo;
1252 wantAgentInfo.wants_.emplace_back(want);
1253 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
1254 wantAgentInfo.requestCode_ = 10;
1255 bool value = true;
1256 std::string key = "key";
1257 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1258 wParams->SetParam(key, Boolean::Box(value));
1259 wantAgentInfo.extraInfo_ = wParams;
1260 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
1261 EXPECT_NE(wantAgent, nullptr);
1262 auto type = wantAgentHelper->GetType(wantAgent);
1263 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1264
1265 // remove death recipient
1266 WantAgentClient::GetInstance().RemoveDeathRecipient();
1267
1268 WantAgentHelper::Cancel(wantAgent);
1269 type = WantAgentHelper::GetType(wantAgent);
1270 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1271 }
1272
1273 /*
1274 * @tc.number : WantAgentHelper_5900
1275 * @tc.name : WantAgentHelper GetWant for local wantagent
1276 * @tc.desc : wantAgent is local and not null
1277 */
1278 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5900, Function | MediumTest | Level1)
1279 {
1280 std::shared_ptr<AAFwk::Want> expectedWant = std::make_shared<AAFwk::Want>();
1281 expectedWant->SetElement(ElementName("deviceId", "bundleName", "abilityName"));
1282 std::shared_ptr<LocalPendingWant> localPendingWant = std::make_shared<LocalPendingWant>(
1283 "TestBundleName", expectedWant, 0);
1284 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(localPendingWant);
1285 std::shared_ptr<AAFwk::Want> actualWant;
1286
1287 WantAgentHelper::GetWant(wantAgent, actualWant);
1288 ASSERT_EQ(actualWant->GetElement().GetBundleName(), expectedWant->GetElement().GetBundleName());
1289 ASSERT_EQ(WantAgentHelper::GetWant(wantAgent)->GetElement().GetBundleName(),
1290 expectedWant->GetElement().GetBundleName());
1291 }
1292
1293 /*
1294 * @tc.number : WantAgentHelper_6000
1295 * @tc.name : WantAgentHelper GetWant for local wantagent
1296 * @tc.desc : wantAgent is local and null
1297 */
1298 HWTEST_F(WantAgentHelperTest, WantAgentHelper_6000, Function | MediumTest | Level1)
1299 {
1300 std::shared_ptr<LocalPendingWant> localPendingWant = nullptr;
1301 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(localPendingWant);
1302 std::shared_ptr<AAFwk::Want> actualWant;
1303 const auto retCode = WantAgentHelper::GetWant(wantAgent, actualWant);
1304 ASSERT_TRUE(actualWant == nullptr);
1305 ASSERT_TRUE(retCode == ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1306 ASSERT_TRUE(WantAgentHelper::GetWant(wantAgent) == nullptr);
1307 }
1308
1309 /*
1310 * @tc.number : WantAgentHelper_6100
1311 * @tc.name : WantAgentHelper GetType for local wantagent
1312 * @tc.desc : wantAgent is local and not null
1313 */
1314 HWTEST_F(WantAgentHelperTest, WantAgentHelper_6100, Function | MediumTest | Level1)
1315 {
1316 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
1317 want->SetElement(ElementName("deviceId", "bundleName", "abilityName"));
1318 const int32_t expectedType = 100;
1319 std::shared_ptr<LocalPendingWant> localPendingWant = std::make_shared<LocalPendingWant>(
1320 "TestBundleName", want, expectedType);
1321 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(localPendingWant);
1322 int32_t actualType = 0;
1323 WantAgentHelper::GetType(wantAgent, actualType);
1324 ASSERT_EQ(actualType, expectedType);
1325 ASSERT_EQ(static_cast<int32_t>(WantAgentHelper::GetType(wantAgent)), expectedType);
1326 }
1327
1328 /*
1329 * @tc.number : WantAgentHelper_6200
1330 * @tc.name : WantAgentHelper GetType for local wantagent
1331 * @tc.desc : wantAgent is local and null
1332 */
1333 HWTEST_F(WantAgentHelperTest, WantAgentHelper_6200, Function | MediumTest | Level1)
1334 {
1335 std::shared_ptr<LocalPendingWant> localPendingWant = nullptr;
1336 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(localPendingWant);
1337 int32_t actualType = 0;
1338 const auto retCode = WantAgentHelper::GetType(wantAgent, actualType);
1339 ASSERT_TRUE(retCode == ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1340 ASSERT_TRUE(WantAgentHelper::GetType(wantAgent) == WantAgentConstant::OperationType::UNKNOWN_TYPE);
1341 }
1342
1343 /*
1344 * @tc.number : WantAgentHelper_6300
1345 * @tc.name : WantAgentHelper GetUid for local wantagent
1346 * @tc.desc : wantAgent is local and not null
1347 */
1348 HWTEST_F(WantAgentHelperTest, WantAgentHelper_6300, Function | MediumTest | Level1)
1349 {
1350 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
1351 want->SetElement(ElementName("deviceId", "bundleName", "abilityName"));
1352 const int32_t expectedUid = 6200;
1353 std::shared_ptr<LocalPendingWant> localPendingWant = std::make_shared<LocalPendingWant>(
1354 "TestBundleName", want, 0);
1355 localPendingWant->SetUid(expectedUid);
1356 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(localPendingWant);
1357 int32_t actualUid = 0;
1358 WantAgentHelper::GetUid(wantAgent, actualUid);
1359 ASSERT_EQ(actualUid, expectedUid);
1360 }
1361
1362 /*
1363 * @tc.number : WantAgentHelper_6400
1364 * @tc.name : WantAgentHelper GetUid for local wantagent
1365 * @tc.desc : wantAgent is local and null
1366 */
1367 HWTEST_F(WantAgentHelperTest, WantAgentHelper_6400, Function | MediumTest | Level1)
1368 {
1369 std::shared_ptr<LocalPendingWant> localPendingWant = nullptr;
1370 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(localPendingWant);
1371 int32_t actualUid = 0;
1372 const auto retCode = WantAgentHelper::GetType(wantAgent, actualUid);
1373 ASSERT_TRUE(retCode == ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1374 }
1375
1376 /*
1377 * @tc.number : WantAgentHelper_6500
1378 * @tc.name : WantAgentHelper GetBundleName for local wantagent
1379 * @tc.desc : wantAgent is local and not null
1380 */
1381 HWTEST_F(WantAgentHelperTest, WantAgentHelper_6500, Function | MediumTest | Level1)
1382 {
1383 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
1384 want->SetElement(ElementName("deviceId", "bundleName", "abilityName"));
1385 const std::string expectedBundleName = "TestBundleName";
1386 std::shared_ptr<LocalPendingWant> localPendingWant = std::make_shared<LocalPendingWant>(
1387 expectedBundleName, want, 0);
1388 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(localPendingWant);
1389 std::string actualBundleName;
1390 WantAgentHelper::GetBundleName(wantAgent, actualBundleName);
1391 ASSERT_EQ(actualBundleName, expectedBundleName);
1392 }
1393
1394 /*
1395 * @tc.number : WantAgentHelper_6600
1396 * @tc.name : WantAgentHelper GetBundleName for local wantagent
1397 * @tc.desc : wantAgent is local and null
1398 */
1399 HWTEST_F(WantAgentHelperTest, WantAgentHelper_6600, Function | MediumTest | Level1)
1400 {
1401 std::shared_ptr<LocalPendingWant> localPendingWant = nullptr;
1402 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(localPendingWant);
1403 std::string actualBundleName;
1404 const auto retCode = WantAgentHelper::GetBundleName(wantAgent, actualBundleName);
1405 ASSERT_TRUE(retCode == ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1406 }
1407
1408 /**
1409 * @tc.name: CreateLocalWantAgent_0100
1410 * @tc.desc: Test CreateLocalWantAgent with null context
1411 * @tc.type: FUNC
1412 */
1413 HWTEST_F(WantAgentHelperTest, CreateLocalWantAgent_0100, TestSize.Level1)
1414 {
1415 std::shared_ptr<Want> want = std::make_shared<Want>();
1416 std::vector<std::shared_ptr<Want>> wants = {want};
1417 LocalWantAgentInfo paramsInfo(10, WantAgentConstant::OperationType::START_ABILITY, wants);
1418
1419 auto requestCode = paramsInfo.GetRequestCode();
1420 EXPECT_EQ(requestCode, 10);
1421 auto operationType = paramsInfo.GetOperationType();
1422 EXPECT_EQ(operationType, WantAgentConstant::OperationType::START_ABILITY);
1423 auto wantGet = paramsInfo.GetWants();
1424 EXPECT_EQ(wantGet.size(), 1);
1425
1426 std::shared_ptr<WantAgent> wantAgent;
1427 ErrCode result = WantAgentHelper::CreateLocalWantAgent(nullptr, paramsInfo, wantAgent);
1428
1429 EXPECT_EQ(result, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1430 }
1431
1432 /**
1433 * @tc.name: CreateLocalWantAgent_0200
1434 * @tc.desc: Test CreateLocalWantAgent with empty wants
1435 * @tc.type: FUNC
1436 */
1437 HWTEST_F(WantAgentHelperTest, CreateLocalWantAgent_0200, TestSize.Level1)
1438 {
1439 auto context = std::make_shared<ApplicationContext>();
1440
1441 std::vector<std::shared_ptr<Want>> wants;
1442 LocalWantAgentInfo paramsInfo(10, WantAgentConstant::OperationType::START_ABILITY, wants);
1443
1444 std::shared_ptr<WantAgent> wantAgent;
1445 ErrCode result = WantAgentHelper::CreateLocalWantAgent(context, paramsInfo, wantAgent);
1446
1447 EXPECT_EQ(result, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1448 }
1449
1450 /**
1451 * @tc.name: CreateLocalWantAgent_0300
1452 * @tc.desc: Test CreateLocalWantAgent with null want in wants
1453 * @tc.type: FUNC
1454 */
1455 HWTEST_F(WantAgentHelperTest, CreateLocalWantAgent_0300, TestSize.Level1)
1456 {
1457 auto context = std::make_shared<ApplicationContext>();
1458
1459 std::vector<std::shared_ptr<Want>> wants = {nullptr};
1460 LocalWantAgentInfo paramsInfo(10, WantAgentConstant::OperationType::START_ABILITY, wants);
1461
1462 std::shared_ptr<WantAgent> wantAgent;
1463 ErrCode result = WantAgentHelper::CreateLocalWantAgent(context, paramsInfo, wantAgent);
1464
1465 EXPECT_EQ(result, ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_PARAMETER);
1466 }
1467
1468 /**
1469 * @tc.name: CreateLocalWantAgent_0400
1470 * @tc.desc: Test CreateLocalWantAgent with valid parameters
1471 * @tc.type: FUNC
1472 */
1473 HWTEST_F(WantAgentHelperTest, CreateLocalWantAgent_0400, TestSize.Level1)
1474 {
1475 auto context = std::make_shared<ApplicationContext>();
1476
1477 std::shared_ptr<Want> want = std::make_shared<Want>();
1478 std::vector<std::shared_ptr<Want>> wants = {want};
1479 LocalWantAgentInfo paramsInfo(10, WantAgentConstant::OperationType::START_ABILITY, wants);
1480
1481 std::shared_ptr<WantAgent> wantAgent;
1482 ErrCode result = WantAgentHelper::CreateLocalWantAgent(context, paramsInfo, wantAgent);
1483
1484 EXPECT_EQ(result, ERR_OK);
1485
1486 // Verify the created WantAgent
1487 std::shared_ptr<Want> retrievedWant;
1488 ErrCode getWantResult = WantAgentHelper::GetWant(wantAgent, retrievedWant);
1489 EXPECT_EQ(getWantResult, ERR_OK);
1490
1491 int32_t operationType;
1492 ErrCode getTypeResult = WantAgentHelper::GetType(wantAgent, operationType);
1493 EXPECT_EQ(getTypeResult, ERR_OK);
1494 EXPECT_EQ(operationType, static_cast<int32_t>(WantAgentConstant::OperationType::START_ABILITY));
1495 }
1496
1497 /**
1498 * @tc.name: CreateLocalWantAgent_0500
1499 * @tc.desc: Test CreateLocalWantAgent with different operation types
1500 * @tc.type: FUNC
1501 */
1502 HWTEST_F(WantAgentHelperTest, CreateLocalWantAgent_0500, TestSize.Level1)
1503 {
1504 auto context = std::make_shared<ApplicationContext>();
1505
1506 std::shared_ptr<Want> want = std::make_shared<Want>();
1507 std::vector<std::shared_ptr<Want>> wants = {want};
1508 LocalWantAgentInfo paramsInfo(10, WantAgentConstant::OperationType::SEND_COMMON_EVENT, wants);
1509
1510 std::shared_ptr<WantAgent> wantAgent;
1511 ErrCode result = WantAgentHelper::CreateLocalWantAgent(context, paramsInfo, wantAgent);
1512
1513 EXPECT_EQ(result, ERR_OK);
1514
1515 int32_t operationType;
1516 ErrCode getTypeResult = WantAgentHelper::GetType(wantAgent, operationType);
1517 EXPECT_EQ(getTypeResult, ERR_OK);
1518 EXPECT_EQ(operationType, static_cast<int32_t>(WantAgentConstant::OperationType::SEND_COMMON_EVENT));
1519 }
1520 } // namespace OHOS::AbilityRuntime::WantAgent
1521