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_info.h"
40 #undef private
41 #undef protected
42 #include "want_params.h"
43 #include "want_receiver_stub.h"
44 #include "want_sender_stub.h"
45 #include "bool_wrapper.h"
46
47 using namespace testing::ext;
48 using namespace OHOS::AAFwk;
49 using namespace OHOS;
50 using OHOS::AppExecFwk::ElementName;
51 using namespace OHOS::AbilityRuntime;
52 using namespace OHOS::AppExecFwk;
53 using vector_str = std::vector<std::string>;
54
55 namespace OHOS::AbilityRuntime::WantAgent {
56 class WantAgentHelperTest : public testing::Test {
57 public:
WantAgentHelperTest()58 WantAgentHelperTest()
59 {}
~WantAgentHelperTest()60 ~WantAgentHelperTest()
61 {}
62 static void SetUpTestCase(void);
63 static void TearDownTestCase(void);
64 static int callBackCancelListenerConnt;
65 void SetUp();
66 void TearDown();
67 class CancelListenerSon : public CancelListener {
68 public:
69 void OnCancelled(int resultCode) override;
70 };
71 };
72
73 int WantAgentHelperTest::callBackCancelListenerConnt = 0;
74
OnCancelled(int resultCode)75 void WantAgentHelperTest::CancelListenerSon::OnCancelled(int resultCode)
76 {
77 callBackCancelListenerConnt++;
78 }
79
SetUpTestCase(void)80 void WantAgentHelperTest::SetUpTestCase(void)
81 {
82 RemoteNativeToken::SetNativeToken();
83 }
84
TearDownTestCase(void)85 void WantAgentHelperTest::TearDownTestCase(void)
86 {}
87
SetUp(void)88 void WantAgentHelperTest::SetUp(void)
89 {}
90
TearDown(void)91 void WantAgentHelperTest::TearDown(void)
92 {}
93
94 /*
95 * @tc.number : WantAgentHelper_0100
96 * @tc.name : WantAgentHelper Constructors
97 * @tc.desc : 1.WantAgentConstant::Flags::ONE_TIME_FLAG
98 */
99 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0100, Function | MediumTest | Level1)
100 {
101 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
102 std::vector<WantAgentConstant::Flags> flags;
103 flags.emplace_back(WantAgentConstant::Flags::ONE_TIME_FLAG);
104 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0x40000000));
105 }
106
107 /*
108 * @tc.number : WantAgentHelper_0200
109 * @tc.name : WantAgentHelper Constructors
110 * @tc.desc : 1.WantAgentConstant::Flags::NO_BUILD_FLAG
111 */
112 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0200, Function | MediumTest | Level1)
113 {
114 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
115 std::vector<WantAgentConstant::Flags> flags;
116 flags.emplace_back(WantAgentConstant::Flags::NO_BUILD_FLAG);
117 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0x20000000));
118 }
119
120 /*
121 * @tc.number : WantAgentHelper_0300
122 * @tc.name : WantAgentHelper Constructors
123 * @tc.desc : 1.WantAgentConstant::Flags::CANCEL_PRESENT_FLAG
124 */
125 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0300, Function | MediumTest | Level1)
126 {
127 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
128 std::vector<WantAgentConstant::Flags> flags;
129 flags.emplace_back(WantAgentConstant::Flags::CANCEL_PRESENT_FLAG);
130 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0x10000000));
131 }
132
133 /*
134 * @tc.number : WantAgentHelper_0400
135 * @tc.name : WantAgentHelper Constructors
136 * @tc.desc : 1.WantAgentConstant::Flags::UPDATE_PRESENT_FLAG
137 */
138 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0400, Function | MediumTest | Level1)
139 {
140 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
141 std::vector<WantAgentConstant::Flags> flags;
142 flags.emplace_back(WantAgentConstant::Flags::UPDATE_PRESENT_FLAG);
143 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0x8000000));
144 }
145
146 /*
147 * @tc.number : WantAgentHelper_0500
148 * @tc.name : WantAgentHelper Constructors
149 * @tc.desc : 1.WantAgentConstant::Flags::CONSTANT_FLAG
150 */
151 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0500, Function | MediumTest | Level1)
152 {
153 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
154 std::vector<WantAgentConstant::Flags> flags;
155 flags.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
156 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0x4000000));
157 }
158
159 /*
160 * @tc.number : WantAgentHelper_0600
161 * @tc.name : WantAgentHelper Constructors
162 * @tc.desc : 1.WantAgentConstant::Flags::REPLACE_BUNDLE
163 */
164 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0600, Function | MediumTest | Level1)
165 {
166 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
167 std::vector<WantAgentConstant::Flags> flags;
168 flags.emplace_back(WantAgentConstant::Flags::REPLACE_BUNDLE);
169 EXPECT_EQ(
170 wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(FLAG_UPDATE_CURRENT));
171 }
172
173 /*
174 * @tc.number : WantAgentHelper_0700
175 * @tc.name : WantAgentHelper Constructors
176 * @tc.desc : 1.WantAgentConstant::Flags::CONSTANT_FLAG | UPDATE_PRESENT_FLAG | REPLACE_BUNDLE
177 */
178 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0700, Function | MediumTest | Level1)
179 {
180 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
181 std::vector<WantAgentConstant::Flags> flags;
182 flags.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
183 flags.emplace_back(WantAgentConstant::Flags::UPDATE_PRESENT_FLAG);
184 flags.emplace_back(WantAgentConstant::Flags::REPLACE_BUNDLE);
185 EXPECT_EQ(wantAgentHelper->FlagsTransformer(flags), static_cast<unsigned int>(0xc000000));
186 }
187
188 /*
189 * @tc.number : WantAgentHelper_0800
190 * @tc.name : WantAgentHelper GetWantAgent
191 * @tc.desc : 1.GetWantAgent context is nullptr
192 */
193 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0800, Function | MediumTest | Level1)
194 {
195 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
196 WantAgentInfo wantAgentInfo;
197 std::shared_ptr<WantAgent> wantAgent = nullptr;
198 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
199 EXPECT_EQ(wantAgent, nullptr);
200 }
201
202 /*
203 * @tc.number : WantAgentHelper_0900
204 * @tc.name : WantAgentHelper GetWantAgent
205 * @tc.desc : 1.GetWantAgent context is not nullptr
206 * ` 2.wantAgentInfo.wants_ empty
207 */
208 HWTEST_F(WantAgentHelperTest, WantAgentHelper_0900, Function | MediumTest | Level1)
209 {
210 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
211 WantAgentInfo wantAgentInfo;
212 wantAgentInfo.wants_.clear();
213 std::shared_ptr<WantAgent> wantAgent = nullptr;
214 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
215 EXPECT_EQ(wantAgent, nullptr);
216 }
217
218 /*
219 * @tc.number : WantAgentHelper_1000
220 * @tc.name : WantAgentHelper GetWantAgent
221 * @tc.desc : 1.GetWantAgent context is not nullptr
222 * 2.wantAgentInfo.wants_.size() != wantAgentInfo.flags_.size()
223 */
224 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1000, Function | MediumTest | Level1)
225 {
226 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
227 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
228 OHOS::AbilityRuntime::Context::GetApplicationContext();
229 WantAgentInfo wantAgentInfo;
230 std::shared_ptr<Want> want = std::make_shared<Want>();
231 ElementName element("device", "bundleName", "abilityName");
232 want->SetElement(element);
233 wantAgentInfo.wants_.emplace_back(want);
234 wantAgentInfo.flags_.clear();
235 std::shared_ptr<WantAgent> wantAgent = nullptr;
236 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
237 EXPECT_EQ(wantAgent, nullptr);
238 }
239
240 /*
241 * @tc.number : WantAgentHelper_1100
242 * @tc.name : WantAgentHelper GetWantAgent
243 * @tc.desc : 1.GetWantAgent context is not nullptr
244 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
245 * 3.FlagsTransformer return 0
246 */
247 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1100, Function | MediumTest | Level1)
248 {
249 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
250 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
251 OHOS::AbilityRuntime::Context::GetApplicationContext();
252 WantAgentInfo wantAgentInfo;
253 std::shared_ptr<Want> want = std::make_shared<Want>();
254 ElementName element("device", "bundleName", "abilityName");
255 want->SetElement(element);
256 wantAgentInfo.wants_.emplace_back(want);
257 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::REPLACE_BUNDLE);
258 std::shared_ptr<WantAgent> wantAgent = nullptr;
259 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
260 EXPECT_EQ(wantAgent, nullptr);
261 }
262
263 /*
264 * @tc.number : WantAgentHelper_1200
265 * @tc.name : WantAgentHelper GetWantAgent
266 * @tc.desc : 1.GetWantAgent context is not nullptr
267 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
268 * 3.FlagsTransformer return ok
269 * 4.Type is WantAgentConstant::OperationType::START_ABILITY
270 */
271 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1200, Function | MediumTest | Level1)
272 {
273 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
274 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
275 AbilityRuntime::ApplicationContext::GetInstance();
276 std::shared_ptr<Want> want = std::make_shared<Want>();
277 ElementName element("device", "bundleName", "abilityName");
278 want->SetElement(element);
279 WantAgentInfo wantAgentInfo;
280 wantAgentInfo.wants_.emplace_back(want);
281 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
282 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
283 wantAgentInfo.requestCode_ = 10;
284 std::shared_ptr<WantAgent> wantAgent = nullptr;
285 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
286 EXPECT_EQ(wantAgent, nullptr);
287 }
288
289 /*
290 * @tc.number : WantAgentHelper_1300
291 * @tc.name : WantAgentHelper GetWantAgent
292 * @tc.desc : 1.GetWantAgent context is not nullptr
293 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
294 * 3.FlagsTransformer return ok
295 * 4.Type is WantAgentConstant::OperationType::START_ABILITIES
296 */
297 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1300, Function | MediumTest | Level1)
298 {
299 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
300 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
301 AbilityRuntime::ApplicationContext::GetInstance();
302 std::shared_ptr<Want> want = std::make_shared<Want>();
303 ElementName element("device", "bundleName", "abilityName");
304 want->SetElement(element);
305 WantAgentInfo wantAgentInfo;
306 wantAgentInfo.wants_.emplace_back(want);
307 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
308 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITIES;
309 wantAgentInfo.requestCode_ = 10;
310 std::shared_ptr<WantAgent> wantAgent = nullptr;
311 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
312 EXPECT_EQ(wantAgent, nullptr);
313 }
314
315 /*
316 * @tc.number : WantAgentHelper_1400
317 * @tc.name : WantAgentHelper GetWantAgent
318 * @tc.desc : 1.GetWantAgent context is not nullptr
319 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
320 * 3.FlagsTransformer return ok
321 * 4.Type is WantAgentConstant::OperationType::START_SERVICE
322 */
323 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1400, Function | MediumTest | Level1)
324 {
325 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
326 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
327 AbilityRuntime::ApplicationContext::GetInstance();
328 std::shared_ptr<Want> want = std::make_shared<Want>();
329 ElementName element("device", "bundleName", "abilityName");
330 want->SetElement(element);
331 WantAgentInfo wantAgentInfo;
332 wantAgentInfo.wants_.emplace_back(want);
333 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
334 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_SERVICE;
335 wantAgentInfo.requestCode_ = 10;
336 std::shared_ptr<WantAgent> wantAgent = nullptr;
337 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
338 EXPECT_EQ(wantAgent, nullptr);
339 }
340
341 /*
342 * @tc.number : WantAgentHelper_1500
343 * @tc.name : WantAgentHelper GetWantAgent
344 * @tc.desc : 1.GetWantAgent context is not nullptr
345 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
346 * 3.FlagsTransformer return ok
347 * 4.Type is WantAgentConstant::OperationType::START_FOREGROUND_SERVICE
348 */
349 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1500, Function | MediumTest | Level1)
350 {
351 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
352 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
353 AbilityRuntime::ApplicationContext::GetInstance();
354 std::shared_ptr<Want> want = std::make_shared<Want>();
355 ElementName element("device", "bundleName", "abilityName");
356 want->SetElement(element);
357 WantAgentInfo wantAgentInfo;
358 wantAgentInfo.wants_.emplace_back(want);
359 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
360 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
361 wantAgentInfo.requestCode_ = 10;
362 std::shared_ptr<WantAgent> wantAgent = nullptr;
363 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
364 EXPECT_EQ(wantAgent, nullptr);
365 }
366
367 /*
368 * @tc.number : WantAgentHelper_1600
369 * @tc.name : WantAgentHelper GetWantAgent
370 * @tc.desc : 1.GetWantAgent context is not nullptr
371 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
372 * 3.FlagsTransformer return ok
373 * 4.Type is WantAgentConstant::OperationType::START_FOREGROUND_SERVICE
374 */
375 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1600, Function | MediumTest | Level1)
376 {
377 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
378 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
379 AbilityRuntime::ApplicationContext::GetInstance();
380 std::shared_ptr<Want> want = std::make_shared<Want>();
381 ElementName element("device", "bundleName", "abilityName");
382 want->SetElement(element);
383 WantAgentInfo wantAgentInfo;
384 wantAgentInfo.wants_.emplace_back(want);
385 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
386 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::SEND_COMMON_EVENT;
387 wantAgentInfo.requestCode_ = 10;
388 std::shared_ptr<WantAgent> wantAgent = nullptr;
389 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
390 EXPECT_EQ(wantAgent, nullptr);
391 }
392
393 /*
394 * @tc.number : WantAgentHelper_1700
395 * @tc.name : WantAgentHelper GetWantAgent
396 * @tc.desc : 1.GetWantAgent context is not nullptr
397 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
398 * 3.FlagsTransformer return ok
399 * 4.Type is 100
400 */
401 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1700, Function | MediumTest | Level1)
402 {
403 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
404 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
405 AbilityRuntime::ApplicationContext::GetInstance();
406 std::shared_ptr<Want> want = std::make_shared<Want>();
407 ElementName element("device", "bundleName", "abilityName");
408 want->SetElement(element);
409 WantAgentInfo wantAgentInfo;
410 wantAgentInfo.wants_.emplace_back(want);
411 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
412 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
413 wantAgentInfo.requestCode_ = 10;
414 std::shared_ptr<WantAgent> wantAgent = nullptr;
415 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
416 EXPECT_EQ(wantAgent, nullptr);
417 }
418
419 /*
420 * @tc.number : WantAgentHelper_1800
421 * @tc.name : WantAgentHelper GetWantAgent(const WantAgentInfo ¶msInfo)
422 * @tc.desc : 1.wantAgentInfo.wants_.size() == 0
423 */
424 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1800, Function | MediumTest | Level1)
425 {
426 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
427 WantAgentInfo wantAgentInfo;
428 wantAgentInfo.wants_.clear();
429 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
430 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
431 wantAgentInfo.requestCode_ = 10;
432 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
433 EXPECT_EQ(wantAgent, nullptr);
434 }
435
436 /*
437 * @tc.number : WantAgentHelper_1900
438 * @tc.name : WantAgentHelper GetWantAgent(const WantAgentInfo ¶msInfo)
439 * @tc.desc : 1.wantAgentInfo.wants_ not empty
440 * 2.wantAgentInfo.wants_.size() != wantAgentInfo.flags_.size()
441 */
442 HWTEST_F(WantAgentHelperTest, WantAgentHelper_1900, Function | MediumTest | Level1)
443 {
444 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
445 std::shared_ptr<Want> want = std::make_shared<Want>();
446 ElementName element("device", "bundleName", "abilityName");
447 want->SetElement(element);
448 WantAgentInfo wantAgentInfo;
449 wantAgentInfo.wants_.emplace_back(want);
450 wantAgentInfo.flags_.clear();
451 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
452 wantAgentInfo.requestCode_ = 10;
453 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
454 EXPECT_NE(wantAgent, nullptr);
455 }
456
457 /*
458 * @tc.number : WantAgentHelper_2000
459 * @tc.name : WantAgentHelper GetWantAgent(const WantAgentInfo ¶msInfo)
460 * @tc.desc : 1.wantAgentInfo.wants_ not empty
461 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
462 * 3.wantAgentInfo.wants_[0] is nullptr
463 */
464 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2000, Function | MediumTest | Level1)
465 {
466 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
467 std::shared_ptr<Want> want = std::make_shared<Want>();
468 ElementName element("device", "bundleName", "abilityName");
469 want->SetElement(element);
470 WantAgentInfo wantAgentInfo;
471 wantAgentInfo.wants_.emplace_back(nullptr);
472 wantAgentInfo.wants_.emplace_back(want);
473 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
474 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
475 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
476 wantAgentInfo.requestCode_ = 10;
477 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
478 EXPECT_EQ(wantAgent, nullptr);
479 }
480
481 /*
482 * @tc.number : WantAgentHelper_2100
483 * @tc.name : WantAgentHelper GetWantAgent(const WantAgentInfo ¶msInfo)
484 * @tc.desc : 1.wantAgentInfo.wants_ not empty
485 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
486 * 3.wantAgentInfo.wants_[0] is not nullptr
487 * 4.wantAgentInfo.extraInfo_ is not nullptr
488 */
489 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2100, Function | MediumTest | Level1)
490 {
491 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
492 std::shared_ptr<Want> want = std::make_shared<Want>();
493 ElementName element("device", "bundleName", "abilityName");
494 want->SetElement(element);
495 WantAgentInfo wantAgentInfo;
496 wantAgentInfo.wants_.emplace_back(want);
497 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
498 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
499 wantAgentInfo.requestCode_ = 10;
500 bool value = true;
501 std::string key = "key";
502 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
503 wParams->SetParam(key, Boolean::Box(value));
504 wantAgentInfo.extraInfo_ = wParams;
505 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
506 EXPECT_NE(wantAgent, nullptr);
507 }
508
509 /*
510 * @tc.number : WantAgentHelper_2200
511 * @tc.name : WantAgentHelper GetWantAgent(const WantAgentInfo ¶msInfo)
512 * @tc.desc : 1.wantAgentInfo.wants_ not empty
513 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
514 * 3.wantAgentInfo.wants_[0] is not nullptr
515 * 4.wantAgentInfo.extraInfo_ is nullptr
516 */
517 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2200, Function | MediumTest | Level1)
518 {
519 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
520 std::shared_ptr<Want> want = std::make_shared<Want>();
521 ElementName element("device", "bundleName", "abilityName");
522 want->SetElement(element);
523 WantAgentInfo wantAgentInfo;
524 wantAgentInfo.wants_.emplace_back(want);
525 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::CONSTANT_FLAG);
526 wantAgentInfo.operationType_ = static_cast<WantAgentConstant::OperationType>(100);
527 wantAgentInfo.requestCode_ = 10;
528 wantAgentInfo.extraInfo_ = nullptr;
529 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
530 EXPECT_NE(wantAgent, nullptr);
531 }
532
533 /*
534 * @tc.number : WantAgentHelper_2300
535 * @tc.name : WantAgentHelper GetType
536 * @tc.desc : 1.agent is not nullptr
537 */
538 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2300, Function | MediumTest | Level1)
539 {
540 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
541 WantAgentInfo wantAgentInfo;
542 std::shared_ptr<WantAgent> wantAgent = nullptr;
543 wantAgentHelper->GetWantAgent(nullptr, wantAgentInfo, wantAgent);
544 auto type = wantAgentHelper->GetType(wantAgent);
545 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
546 }
547
548 /*
549 * @tc.number : WantAgentHelper_2400
550 * @tc.name : WantAgentHelper GetType
551 * @tc.desc : 1.agent is not nullptr
552 */
553 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2400, Function | MediumTest | Level1)
554 {
555 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
556 std::shared_ptr<WantAgent> wantAgent(nullptr);
557 auto type = wantAgentHelper->GetType(wantAgent);
558 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
559 }
560
561 /*
562 * @tc.number : WantAgentHelper_2500
563 * @tc.name : WantAgentHelper GetType
564 * @tc.desc : 1.agent is not nullptr,PendingWant is nullptr
565 */
566 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2500, Function | MediumTest | Level1)
567 {
568 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
569 std::shared_ptr<PendingWant> pendingWant(nullptr);
570 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
571 auto type = wantAgentHelper->GetType(wantAgent);
572 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
573 }
574
575 /*
576 * @tc.number : WantAgentHelper_2600
577 * @tc.name : WantAgentHelper JudgeEquality
578 * @tc.desc : 1.JudgeEquality
579 */
580 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2600, Function | MediumTest | Level1)
581 {
582 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
583 std::shared_ptr<WantAgent> wantAgent(nullptr);
584 std::shared_ptr<WantAgent> wantAgent2(nullptr);
585 ErrCode isEqual = wantAgentHelper->IsEquals(wantAgent, wantAgent2);
586 EXPECT_EQ(isEqual, ERR_OK);
587 }
588
589 /*
590 * @tc.number : WantAgentHelper_2700
591 * @tc.name : WantAgentHelper JudgeEquality
592 * @tc.desc : 1.JudgeEquality,Judge whether it is equal or not
593 */
594 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2700, Function | MediumTest | Level1)
595 {
596 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
597
598 // pendingwant
599 int requestCode = 10;
600 std::shared_ptr<Want> want = std::make_shared<Want>();
601 ElementName element("device", "bundleName", "abilityName");
602 want->SetElement(element);
603 unsigned int flags = 1;
604 flags |= FLAG_ONE_SHOT;
605 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
606 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
607 AbilityRuntime::ApplicationContext::GetInstance();
608 std::shared_ptr<PendingWant> pendingWant = nullptr;
609 PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
610
611 // pendingwant2
612 int requestCode2 = 11;
613 std::shared_ptr<Want> want2 = std::make_shared<Want>();
614 ElementName element2("device", "bundle", "ability");
615 want2->SetElement(element2);
616 std::shared_ptr<PendingWant> pendingWant2 = nullptr;
617 PendingWant::BuildServicePendingWant(context, requestCode2, want2, flags, type, pendingWant2);
618
619 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
620 std::shared_ptr<WantAgent> wantAgent2 = std::make_shared<WantAgent>(pendingWant2);
621 ErrCode isEqual = wantAgentHelper->IsEquals(wantAgent, wantAgent2);
622 EXPECT_NE(isEqual, ERR_OK);
623 }
624
625 /*
626 * @tc.number : WantAgentHelper_2800
627 * @tc.name : WantAgentHelper JudgeEquality
628 * @tc.desc : 1.JudgeEquality,Judge whether it is equal or not
629 */
630 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2800, Function | MediumTest | Level1)
631 {
632 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
633
634 int requestCode = 10;
635 std::shared_ptr<Want> want = std::make_shared<Want>();
636 ElementName element("device", "bundleName", "abilityName");
637 want->SetElement(element);
638 unsigned int flags = 1;
639 flags |= FLAG_ONE_SHOT;
640 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
641 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
642 AbilityRuntime::ApplicationContext::GetInstance();
643 std::shared_ptr<PendingWant> pendingWant = nullptr;
644 PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
645
646 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
647 std::shared_ptr<WantAgent> wantAgent2 = std::make_shared<WantAgent>(pendingWant);
648 ErrCode isEqual = wantAgentHelper->IsEquals(wantAgent, wantAgent2);
649 EXPECT_EQ(isEqual, ERR_OK);
650 }
651
652 /*
653 * @tc.number : WantAgentHelper_2900
654 * @tc.name : WantAgentHelper JudgeEquality
655 * @tc.desc : 1.JudgeEquality,Judge whether it is equal or not
656 */
657 HWTEST_F(WantAgentHelperTest, WantAgentHelper_2900, Function | MediumTest | Level1)
658 {
659 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
660
661 int requestCode = 10;
662 std::shared_ptr<Want> want = std::make_shared<Want>();
663 ElementName element("device", "bundleName", "abilityName");
664 want->SetElement(element);
665 unsigned int flags = 1;
666 flags |= FLAG_ONE_SHOT;
667 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
668 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
669 AbilityRuntime::ApplicationContext::GetInstance();
670 std::shared_ptr<PendingWant> pendingWant = nullptr;
671 PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
672
673 std::shared_ptr<PendingWant> pendingWant2(nullptr);
674 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
675 std::shared_ptr<WantAgent> wantAgent2 = std::make_shared<WantAgent>(pendingWant2);
676 ErrCode isEqual = wantAgentHelper->IsEquals(wantAgent, wantAgent2);
677 EXPECT_NE(isEqual, ERR_OK);
678 }
679
680 /*
681 * @tc.number : WantAgentHelper_3000
682 * @tc.name : WantAgentHelper GetBundleName
683 * @tc.desc : 1.GetBundleName WantAgent is nullptr
684 */
685 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3000, Function | MediumTest | Level1)
686 {
687 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
688 std::shared_ptr<WantAgent> wantAgent(nullptr);
689 std::string bundleName = "";
690 wantAgentHelper->GetBundleName(wantAgent, bundleName);
691 EXPECT_EQ(bundleName, "");
692 }
693
694 /*
695 * @tc.number : WantAgentHelper_3100
696 * @tc.name : WantAgentHelper GetBundleName
697 * @tc.desc : 1.GetBundleName WantAgent.PendingWant.target is nullptr
698 */
699 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3100, Function | MediumTest | Level1)
700 {
701 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
702 std::shared_ptr<PendingWant> pendingWant(nullptr);
703 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
704 std::string bundleName = "";
705 wantAgentHelper->GetBundleName(wantAgent, bundleName);
706 EXPECT_EQ(bundleName, "");
707 }
708
709 /*
710 * @tc.number : WantAgentHelper_3200
711 * @tc.name : WantAgentHelper GetUid
712 * @tc.desc : 1.GetUid WantAgent is nullptr
713 */
714 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3200, Function | MediumTest | Level1)
715 {
716 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
717 EXPECT_NE(wantAgentHelper, nullptr);
718 std::shared_ptr<WantAgent> wantAgent(nullptr);
719 int32_t uid = -1;
720 wantAgentHelper->GetUid(wantAgent, uid);
721 }
722
723 /*
724 * @tc.number : WantAgentHelper_3300
725 * @tc.name : WantAgentHelper GetUid
726 * @tc.desc : 1.GetUid WantAgent.PendingWant.target is nullptr
727 */
728 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3300, Function | MediumTest | Level1)
729 {
730 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
731 EXPECT_NE(wantAgentHelper, nullptr);
732 std::shared_ptr<PendingWant> pendingWant(nullptr);
733 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
734 int32_t uid = -1;
735 wantAgentHelper->GetUid(wantAgent, uid);
736 }
737
738 /*
739 * @tc.number : WantAgentHelper_3400
740 * @tc.name : WantAgentHelper GetWant
741 * @tc.desc : 1.GetWant WantAgent is nullptr
742 */
743 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3400, Function | MediumTest | Level1)
744 {
745 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
746 std::shared_ptr<WantAgent> wantAgent(nullptr);
747 auto want = wantAgentHelper->GetWant(wantAgent);
748 EXPECT_EQ(want, nullptr);
749 }
750
751 /*
752 * @tc.number : WantAgentHelper_3500
753 * @tc.name : WantAgentHelper GetWant
754 * @tc.desc : 1.GetWant WantAgent.PendingWant.target is nullptr
755 */
756 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3500, Function | MediumTest | Level1)
757 {
758 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
759 std::shared_ptr<PendingWant> pendingWant(nullptr);
760 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
761 auto want = wantAgentHelper->GetWant(wantAgent);
762 EXPECT_EQ(want, nullptr);
763 }
764
765 /*
766 * @tc.number : WantAgentHelper_3600
767 * @tc.name : WantAgentHelper ParseFlags
768 * @tc.desc : 1.ParseFlags Check ParseFlags
769 */
770 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3600, Function | MediumTest | Level1)
771 {
772 std::vector<WantAgentConstant::Flags> flagsVec;
773 nlohmann::json jsonObject;
774
775 jsonObject["flags"] = -1;
776 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
777 EXPECT_EQ(flagsVec.size(), 0);
778
779 jsonObject.clear();
780 jsonObject["flags"] = 1111000000;
781 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
782 std::vector<WantAgentConstant::Flags>::iterator oneTimeIt = std::find(flagsVec.begin(), flagsVec.end(),
783 WantAgentConstant::Flags::ONE_TIME_FLAG);
784 EXPECT_EQ(oneTimeIt != flagsVec.end(), true);
785
786 jsonObject.clear();
787 jsonObject["flags"] = 111100000000000;
788 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
789 std::vector<WantAgentConstant::Flags>::iterator cancelPresentIt = std::find(flagsVec.begin(), flagsVec.end(),
790 WantAgentConstant::Flags::CANCEL_PRESENT_FLAG);
791 EXPECT_EQ(cancelPresentIt != flagsVec.end(), true);
792
793 jsonObject.clear();
794 jsonObject["flags"] = 111100000000000;
795 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
796 std::vector<WantAgentConstant::Flags>::iterator updateResentIt = std::find(flagsVec.begin(), flagsVec.end(),
797 WantAgentConstant::Flags::UPDATE_PRESENT_FLAG);
798 EXPECT_EQ(updateResentIt != flagsVec.end(), true);
799
800 jsonObject.clear();
801 jsonObject["flags"] = 111100000000000;
802 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
803 std::vector<WantAgentConstant::Flags>::iterator constantIt = std::find(flagsVec.begin(), flagsVec.end(),
804 WantAgentConstant::Flags::CONSTANT_FLAG);
805 EXPECT_EQ(constantIt != flagsVec.end(), true);
806
807 jsonObject.clear();
808 jsonObject["flags"] = 1000000000;
809 flagsVec = WantAgentHelper::ParseFlags(jsonObject);
810 std::vector<WantAgentConstant::Flags>::iterator noBuildIt = std::find(flagsVec.begin(), flagsVec.end(),
811 WantAgentConstant::Flags::NO_BUILD_FLAG);
812 EXPECT_EQ(noBuildIt != flagsVec.end(), true);
813 }
814
815 /*
816 * @tc.number : WantAgentHelper_3700
817 * @tc.name : WantAgentHelper GetType
818 * @tc.desc : 1.agent is nullptr
819 */
820 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3700, Function | MediumTest | Level1)
821 {
822 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
823 std::shared_ptr<WantAgent> wantAgent(nullptr);
824 int32_t type = static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE);
825 EXPECT_EQ(wantAgentHelper->GetType(wantAgent, type), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
826 EXPECT_EQ(type, static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE));
827 }
828
829 /*
830 * @tc.number : WantAgentHelper_3800
831 * @tc.name : WantAgentHelper GetType
832 * @tc.desc : 1.agent is not nullptr,PendingWant is nullptr
833 */
834 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3800, Function | MediumTest | Level1)
835 {
836 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
837 std::shared_ptr<PendingWant> pendingWant(nullptr);
838 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
839 auto type = static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE);
840 EXPECT_EQ(wantAgentHelper->GetType(wantAgent, type), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
841 EXPECT_EQ(type, static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE));
842 }
843
844 /*
845 * @tc.number : WantAgentHelper_3900
846 * @tc.name : WantAgentHelper GetType
847 * @tc.desc : 1.agent is not nullptr, PendingWant is not nullptr
848 */
849 HWTEST_F(WantAgentHelperTest, WantAgentHelper_3900, Function | MediumTest | Level1)
850 {
851 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
852 sptr<AAFwk::IWantSender> target(nullptr);
853 std::shared_ptr<PendingWant> pendingWant = std::make_shared<PendingWant>(target);
854 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
855 auto type = static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE);
856 EXPECT_EQ(wantAgentHelper->GetType(wantAgent, type), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
857 EXPECT_EQ(type, static_cast<int32_t>(WantAgentConstant::OperationType::UNKNOWN_TYPE));
858 }
859
860 /*
861 * @tc.number : WantAgentHelper_4000
862 * @tc.name : WantAgentHelper GetWant
863 * @tc.desc : 1.GetWant WantAgent is nullptr
864 */
865 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4000, Function | MediumTest | Level1)
866 {
867 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
868 std::shared_ptr<WantAgent> wantAgent(nullptr);
869 std::shared_ptr<AAFwk::Want> want(nullptr);
870 EXPECT_EQ(wantAgentHelper->GetWant(wantAgent, want), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
871 EXPECT_EQ(want, nullptr);
872 }
873
874 /*
875 * @tc.number : WantAgentHelper_4100
876 * @tc.name : WantAgentHelper GetWant
877 * @tc.desc : 1.GetWant WantAgent.PendingWant is nullptr
878 */
879 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4100, Function | MediumTest | Level1)
880 {
881 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
882 std::shared_ptr<PendingWant> pendingWant(nullptr);
883 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
884 std::shared_ptr<AAFwk::Want> want(nullptr);
885 EXPECT_EQ(wantAgentHelper->GetWant(wantAgent, want), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
886 EXPECT_EQ(want, nullptr);
887 }
888
889 /*
890 * @tc.number : WantAgentHelper_4200
891 * @tc.name : WantAgentHelper GetWant
892 * @tc.desc : 1.GetWant WantAgent and WantAgent.PendingWant is not nullptr
893 */
894 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4200, Function | MediumTest | Level1)
895 {
896 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
897 sptr<AAFwk::IWantSender> target(nullptr);
898 std::shared_ptr<PendingWant> pendingWant = std::make_shared<PendingWant>(target);
899 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
900 std::shared_ptr<AAFwk::Want> want(nullptr);
901 EXPECT_EQ(wantAgentHelper->GetWant(wantAgent, want), ERR_ABILITY_RUNTIME_EXTERNAL_INVALID_WANTAGENT);
902 EXPECT_EQ(want, nullptr);
903 }
904
905 /*
906 * @tc.number : WantAgentHelper_4500
907 * @tc.name : WantAgentHelper RegisterCancelListener
908 * @tc.desc : 1.RegisterCancelListener when agent is null.
909 */
910 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4500, Function | MediumTest | Level1)
911 {
912 GTEST_LOG_(INFO) << "WantAgentHelper::RegisterCancelListener start";
913
914 std::shared_ptr<CancelListener> cancelListener1 = std::make_shared<CancelListenerSon>();
915 std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
916
917 WantAgentHelper::RegisterCancelListener(cancelListener1, nullptr);
918 WantAgentHelper::RegisterCancelListener(cancelListener2, nullptr);
919
920 GTEST_LOG_(INFO) << "WantAgentHelper::RegisterCancelListener end";
921 }
922
923 /*
924 * @tc.number : WantAgentHelper_4600
925 * @tc.name : WantAgentHelper RegisterCancelListener
926 * @tc.desc : 2.RegisterCancelListener normal test
927 */
928 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4600, Function | MediumTest | Level1)
929 {
930 GTEST_LOG_(INFO) << "WantAgentHelper::RegisterCancelListener start";
931
932 int requestCode = 10;
933 std::shared_ptr<Want> want = std::make_shared<Want>();
934 ElementName element("device", "bundleName", "abilityName");
935 want->SetElement(element);
936 unsigned int flags = 1;
937 flags |= FLAG_ONE_SHOT;
938 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
939 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
940 AbilityRuntime::ApplicationContext::GetInstance();
941 std::shared_ptr<PendingWant> pendingWant = nullptr;
942 PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
943 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
944
945 std::shared_ptr<CancelListener> cancelListener = std::make_shared<CancelListenerSon>();
946
947 WantAgentHelper::RegisterCancelListener(cancelListener, wantAgent);
948
949 EXPECT_EQ(static_cast<int>(wantAgent->GetPendingWant()->cancelListeners_.size()), 1);
950
951 GTEST_LOG_(INFO) << "WantAgentHelper::RegisterCancelListener end";
952 }
953
954 /*
955 * @tc.number : WantAgentHelper_4700
956 * @tc.name : WantAgentHelper UnregisterCancelListener
957 * @tc.desc : 1.UnregisterCancelListener when agent is nullptr.
958 */
959 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4700, Function | MediumTest | Level1)
960 {
961 GTEST_LOG_(INFO) << "WantAgentHelper::UnregisterCancelListener start";
962
963 std::shared_ptr<CancelListener> cancelListener1 = std::make_shared<CancelListenerSon>();
964 std::shared_ptr<CancelListener> cancelListener2 = std::make_shared<CancelListenerSon>();
965 WantAgentHelper::UnregisterCancelListener(cancelListener1, nullptr);
966 WantAgentHelper::UnregisterCancelListener(cancelListener2, nullptr);
967
968 GTEST_LOG_(INFO) << "WantAgentHelper::UnregisterCancelListener end";
969 }
970
971 /*
972 * @tc.number : WantAgentHelper_4800
973 * @tc.name : WantAgentHelper UnregisterCancelListener
974 * @tc.desc : 2.UnregisterCancelListener normal test.
975 */
976 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4800, Function | MediumTest | Level1)
977 {
978 GTEST_LOG_(INFO) << "WantAgentHelper::UnregisterCancelListener start";
979
980 int requestCode = 10;
981 std::shared_ptr<Want> want = std::make_shared<Want>();
982 ElementName element("device", "bundleName", "abilityName");
983 want->SetElement(element);
984 unsigned int flags = 1;
985 flags |= FLAG_ONE_SHOT;
986 WantAgentConstant::OperationType type = WantAgentConstant::OperationType::START_FOREGROUND_SERVICE;
987 std::shared_ptr<AbilityRuntime::ApplicationContext> context =
988 AbilityRuntime::ApplicationContext::GetInstance();
989 std::shared_ptr<PendingWant> pendingWant = nullptr;
990 PendingWant::BuildServicePendingWant(context, requestCode, want, flags, type, pendingWant);
991 std::shared_ptr<WantAgent> wantAgent = std::make_shared<WantAgent>(pendingWant);
992
993 std::shared_ptr<CancelListener> cancelListener = std::make_shared<CancelListenerSon>();
994
995 WantAgentHelper::RegisterCancelListener(cancelListener, wantAgent);
996 EXPECT_EQ(static_cast<int>(wantAgent->GetPendingWant()->cancelListeners_.size()), 1);
997
998 WantAgentHelper::UnregisterCancelListener(cancelListener, wantAgent);
999 EXPECT_EQ(static_cast<int>(wantAgent->GetPendingWant()->cancelListeners_.size()), 0);
1000
1001 GTEST_LOG_(INFO) << "WantAgentHelper::UnregisterCancelListener end";
1002 }
1003
1004 /*
1005 * @tc.number : WantAgentHelper_4900
1006 * @tc.name : WantAgentHelper TriggerWantAgent
1007 * @tc.desc : Test TriggerWantAgent when agent is nullptr.
1008 */
1009 HWTEST_F(WantAgentHelperTest, WantAgentHelper_4900, Function | MediumTest | Level1)
1010 {
1011 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent start";
1012
1013 std::shared_ptr<CompletedCallback> callback;
1014 TriggerInfo paramsInfo;
1015 WantAgentHelper::TriggerWantAgent(nullptr, callback, paramsInfo);
1016
1017 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent end";
1018 }
1019
1020 /*
1021 * @tc.number : WantAgentHelper_5000
1022 * @tc.name : WantAgentHelper TriggerWantAgent
1023 * @tc.desc : Test TriggerWantAgent when callback is nullptr.
1024 */
1025 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5000, Function | MediumTest | Level1)
1026 {
1027 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent start";
1028
1029 std::shared_ptr<WantAgent> wantAgent(nullptr);
1030 TriggerInfo paramsInfo;
1031 WantAgentHelper::TriggerWantAgent(wantAgent, nullptr, paramsInfo);
1032
1033 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent end";
1034 }
1035
1036 /*
1037 * @tc.number : WantAgentHelper_5100
1038 * @tc.name : WantAgentHelper TriggerWantAgent
1039 * @tc.desc : Test TriggerWantAgent.
1040 */
1041 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5100, Function | MediumTest | Level1)
1042 {
1043 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent start";
1044
1045 std::shared_ptr<WantAgent> wantAgent(nullptr);
1046 std::shared_ptr<CompletedCallback> callback;
1047 TriggerInfo paramsInfo;
1048 WantAgentHelper::TriggerWantAgent(wantAgent, callback, paramsInfo);
1049
1050 GTEST_LOG_(INFO) << "WantAgentHelper::TriggerWantAgent end";
1051 }
1052
1053 /*
1054 * @tc.number : WantAgentHelper_5200
1055 * @tc.name : WantAgentHelper ToString
1056 * @tc.desc : Test ToString.
1057 */
1058 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5200, Function | MediumTest | Level1)
1059 {
1060 GTEST_LOG_(INFO) << "WantAgentHelper::ToString start";
1061 std::shared_ptr<WantAgent> agent(nullptr);
1062 auto result = WantAgentHelper::ToString(agent);
1063 EXPECT_TRUE(result == "");
1064 GTEST_LOG_(INFO) << "WantAgentHelper::ToString end";
1065 }
1066
1067 /*
1068 * @tc.number : WantAgentHelper_5300
1069 * @tc.name : WantAgentHelper FromString
1070 * @tc.desc : Test FromString.
1071 */
1072 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5300, Function | MediumTest | Level1)
1073 {
1074 GTEST_LOG_(INFO) << "WantAgentHelper::FromString start";
1075 std::string jsonString;
1076 auto result = WantAgentHelper::FromString(jsonString);
1077 EXPECT_TRUE(result == nullptr);
1078 GTEST_LOG_(INFO) << "WantAgentHelper::FromString end";
1079 }
1080
1081 /*
1082 * @tc.number : WantAgentHelper_5400
1083 * @tc.name : WantAgentHelper Cancel by flags FLAG_ONE_SHOT
1084 * @tc.desc : 1.wantAgentInfo.wants_ not empty
1085 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
1086 * 3.wantAgentInfo.wants_[0] is not nullptr
1087 * 4.wantAgentInfo.extraInfo_ is not nullptr
1088 */
1089 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5400, Function | MediumTest | Level1)
1090 {
1091 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
1092 std::shared_ptr<Want> want = std::make_shared<Want>();
1093 ElementName element("device", "bundleName", "abilityName");
1094 want->SetElement(element);
1095 WantAgentInfo wantAgentInfo;
1096 wantAgentInfo.wants_.emplace_back(want);
1097 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::ONE_TIME_FLAG);
1098 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
1099 wantAgentInfo.requestCode_ = 10;
1100 bool value = true;
1101 std::string key = "key";
1102 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1103 wParams->SetParam(key, Boolean::Box(value));
1104 wantAgentInfo.extraInfo_ = wParams;
1105 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
1106 EXPECT_NE(wantAgent, nullptr);
1107 auto type = wantAgentHelper->GetType(wantAgent);
1108 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1109
1110 WantAgentHelper::Cancel(wantAgent, FLAG_UPDATE_CURRENT);
1111 type = WantAgentHelper::GetType(wantAgent);
1112 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1113
1114 WantAgentHelper::Cancel(wantAgent, FLAG_ONE_SHOT);
1115 type = WantAgentHelper::GetType(wantAgent);
1116 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1117 }
1118
1119 /*
1120 * @tc.number : WantAgentHelper_5500
1121 * @tc.name : WantAgentHelper Cancel again
1122 * @tc.desc : 1.wantAgentInfo.wants_ not empty
1123 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
1124 * 3.wantAgentInfo.wants_[0] is not nullptr
1125 * 4.wantAgentInfo.extraInfo_ is not nullptr
1126 */
1127 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5500, Function | MediumTest | Level1)
1128 {
1129 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
1130 std::shared_ptr<Want> want = std::make_shared<Want>();
1131 ElementName element("device", "bundleName", "abilityName");
1132 want->SetElement(element);
1133 WantAgentInfo wantAgentInfo;
1134 wantAgentInfo.wants_.emplace_back(want);
1135 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::ONE_TIME_FLAG);
1136 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
1137 wantAgentInfo.requestCode_ = 10;
1138 bool value = true;
1139 std::string key = "key";
1140 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1141 wParams->SetParam(key, Boolean::Box(value));
1142 wantAgentInfo.extraInfo_ = wParams;
1143 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
1144 EXPECT_NE(wantAgent, nullptr);
1145 auto type = wantAgentHelper->GetType(wantAgent);
1146 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1147
1148 WantAgentHelper::Cancel(wantAgent);
1149 type = WantAgentHelper::GetType(wantAgent);
1150 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1151
1152 WantAgentHelper::Cancel(wantAgent, FLAG_ONE_SHOT);
1153 type = WantAgentHelper::GetType(wantAgent);
1154 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1155 }
1156
1157 /*
1158 * @tc.number : WantAgentHelper_5600
1159 * @tc.name : WantAgentHelper Cancel by flags FLAG_UPDATE_CURRENT
1160 * @tc.desc : 1.wantAgentInfo.wants_ not empty
1161 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
1162 * 3.wantAgentInfo.wants_[0] is not nullptr
1163 * 4.wantAgentInfo.extraInfo_ is not nullptr
1164 */
1165 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5600, Function | MediumTest | Level1)
1166 {
1167 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
1168 std::shared_ptr<Want> want = std::make_shared<Want>();
1169 ElementName element("device", "bundleName", "abilityName");
1170 want->SetElement(element);
1171 WantAgentInfo wantAgentInfo;
1172 wantAgentInfo.wants_.emplace_back(want);
1173 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
1174 wantAgentInfo.requestCode_ = 10;
1175 bool value = true;
1176 std::string key = "key";
1177 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1178 wParams->SetParam(key, Boolean::Box(value));
1179 wantAgentInfo.extraInfo_ = wParams;
1180 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
1181 EXPECT_NE(wantAgent, nullptr);
1182 auto type = wantAgentHelper->GetType(wantAgent);
1183 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1184
1185 WantAgentHelper::Cancel(wantAgent, FLAG_ONE_SHOT);
1186 type = WantAgentHelper::GetType(wantAgent);
1187 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1188
1189 WantAgentHelper::Cancel(wantAgent, FLAG_UPDATE_CURRENT);
1190 type = WantAgentHelper::GetType(wantAgent);
1191 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1192 }
1193
1194 /*
1195 * @tc.number : WantAgentHelper_5700
1196 * @tc.name : WantAgentHelper Cancel by flags FLAG_ONE_SHOT|FLAG_ALLOW_CANCEL
1197 * @tc.desc : 1.wantAgentInfo.wants_ not empty
1198 * 2.wantAgentInfo.wants_.size() == wantAgentInfo.flags_.size()
1199 * 3.wantAgentInfo.wants_[0] is not nullptr
1200 * 4.wantAgentInfo.extraInfo_ is not nullptr
1201 */
1202 HWTEST_F(WantAgentHelperTest, WantAgentHelper_5700, Function | MediumTest | Level1)
1203 {
1204 std::shared_ptr<WantAgentHelper> wantAgentHelper = std::make_shared<WantAgentHelper>();
1205 std::shared_ptr<Want> want = std::make_shared<Want>();
1206 ElementName element("device", "bundleName", "abilityName");
1207 want->SetElement(element);
1208 WantAgentInfo wantAgentInfo;
1209 wantAgentInfo.wants_.emplace_back(want);
1210 wantAgentInfo.flags_.emplace_back(WantAgentConstant::Flags::ALLOW_CANCEL_FLAG);
1211 wantAgentInfo.operationType_ = WantAgentConstant::OperationType::START_ABILITY;
1212 wantAgentInfo.requestCode_ = 20;
1213 bool value = true;
1214 std::string key = "key";
1215 std::shared_ptr<WantParams> wParams = std::make_shared<WantParams>();
1216 wParams->SetParam(key, Boolean::Box(value));
1217 wantAgentInfo.extraInfo_ = wParams;
1218 auto wantAgent = wantAgentHelper->GetWantAgent(wantAgentInfo);
1219 EXPECT_NE(wantAgent, nullptr);
1220 auto type = wantAgentHelper->GetType(wantAgent);
1221 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1222
1223 WantAgentHelper::Cancel(wantAgent, FLAG_UPDATE_CURRENT);
1224 type = WantAgentHelper::GetType(wantAgent);
1225 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1226
1227 WantAgentHelper::Cancel(wantAgent, FLAG_ONE_SHOT);
1228 type = WantAgentHelper::GetType(wantAgent);
1229 EXPECT_EQ(type, WantAgentConstant::OperationType::START_ABILITY);
1230
1231 WantAgentHelper::Cancel(wantAgent, FLAG_ONE_SHOT|FLAG_ALLOW_CANCEL);
1232 type = WantAgentHelper::GetType(wantAgent);
1233 EXPECT_EQ(type, WantAgentConstant::OperationType::UNKNOWN_TYPE);
1234 }
1235 } // namespace OHOS::AbilityRuntime::WantAgent
1236