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 "bundlemgr/mock_bundle_manager.h"
18 #include "mock_ability_connect_callback.h"
19 #include "mock_native_token.h"
20 #include "ability_manager_errors.h"
21 #include "ability_scheduler.h"
22 #define private public
23 #define protected public
24 #include "ability_event_handler.h"
25 #include "ability_manager_service.h"
26 #undef private
27 #undef protected
28 #include "if_system_ability_manager.h"
29 #include "iservice_registry.h"
30 #define private public
31 #define protected public
32 #include "pending_want_record.h"
33 #include "pending_want_manager.h"
34 #undef private
35 #undef protected
36 #include "sa_mgr_client.h"
37 #include "sender_info.h"
38 #include "system_ability_definition.h"
39 #include "wants_info.h"
40 #include "want_receiver_stub.h"
41 #include "want_sender_stub.h"
42
43 using namespace testing;
44 using namespace testing::ext;
45 using namespace OHOS::AppExecFwk;
46 using OHOS::AppExecFwk::ElementName;
47
48 namespace OHOS {
49 namespace AAFwk {
WaitUntilTaskFinished()50 static void WaitUntilTaskFinished()
51 {
52 const uint32_t maxRetryCount = 1000;
53 const uint32_t sleepTime = 1000;
54 uint32_t count = 0;
55 auto handler = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance()->GetEventHandler();
56 std::atomic<bool> taskCalled(false);
57 auto f = [&taskCalled]() { taskCalled.store(true); };
58 if (handler->PostTask(f)) {
59 while (!taskCalled.load()) {
60 ++count;
61 if (count >= maxRetryCount) {
62 break;
63 }
64 usleep(sleepTime);
65 }
66 }
67 }
68
69 #define SLEEP(milli) std::this_thread::sleep_for(std::chrono::seconds(milli))
70
71 namespace {} // namespace
72 class PendingWantManagerTest : public testing::Test {
73 public:
74 static void SetUpTestCase();
75 static void TearDownTestCase();
76 void SetUp();
77 void TearDown();
78 WantSenderInfo MakeWantSenderInfo(Want &want, int32_t flags, int32_t userId, int32_t type = 1);
79 WantSenderInfo MakeWantSenderInfo(std::vector<Want> &wants, int32_t flags, int32_t userId, int32_t type = 1);
80 std::shared_ptr<PendingWantKey> MakeWantKey(WantSenderInfo &wantSenderInfo);
81 static constexpr int TEST_WAIT_TIME = 100000;
82
83 class CancelReceiver : public AAFwk::WantReceiverStub {
84 public:
85 static int performReceiveCount;
86 static int sendCount;
87 void Send(const int32_t resultCode) override;
88 void PerformReceive(const AAFwk::Want &want, int resultCode, const std::string &data,
89 const AAFwk::WantParams &extras, bool serialized, bool sticky, int sendingUser) override;
AsObject()90 virtual sptr<IRemoteObject> AsObject() override
91 {
92 return nullptr;
93 }
94 };
95
96 public:
97 std::shared_ptr<PendingWantManager> pendingManager_ {nullptr};
98 std::shared_ptr<AbilityManagerService> abilityMs_ {nullptr};
99 std::string test_apl = "";
100 };
101
102 int PendingWantManagerTest::CancelReceiver::performReceiveCount = 0;
103 int PendingWantManagerTest::CancelReceiver::sendCount = 0;
104
Send(const int32_t resultCode)105 void PendingWantManagerTest::CancelReceiver::Send(const int32_t resultCode)
106 {
107 sendCount = 100;
108 }
PerformReceive(const AAFwk::Want & want,int resultCode,const std::string & data,const AAFwk::WantParams & extras,bool serialized,bool sticky,int sendingUser)109 void PendingWantManagerTest::CancelReceiver::PerformReceive(const AAFwk::Want &want, int resultCode,
110 const std::string &data, const AAFwk::WantParams &extras, bool serialized, bool sticky, int sendingUser)
111 {
112 performReceiveCount = 100;
113 }
114
SetUpTestCase()115 void PendingWantManagerTest::SetUpTestCase()
116 {
117 MockNativeToken::SetNativeToken();
118 OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
119 OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
120 }
121
TearDownTestCase()122 void PendingWantManagerTest::TearDownTestCase()
123 {
124 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
125 }
126
SetUp()127 void PendingWantManagerTest::SetUp()
128 {
129 abilityMs_ = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance();
130 abilityMs_->OnStart();
131 WaitUntilTaskFinished();
132 }
133
TearDown()134 void PendingWantManagerTest::TearDown()
135 {
136 abilityMs_->OnStop();
137 }
138
MakeWantSenderInfo(Want & want,int32_t flags,int32_t userId,int32_t type)139 WantSenderInfo PendingWantManagerTest::MakeWantSenderInfo(Want &want, int32_t flags, int32_t userId, int32_t type)
140 {
141 WantSenderInfo wantSenderInfo;
142 wantSenderInfo.type = type;
143 // wantSenderInfo.type is OperationType::START_ABILITY
144 wantSenderInfo.bundleName = "com.ix.hiRadio";
145 wantSenderInfo.resultWho = "RadioTopAbility";
146 int requestCode = 10;
147 wantSenderInfo.requestCode = requestCode;
148 std::vector<WantsInfo> allWant;
149 WantsInfo wantInfo;
150 wantInfo.want = want;
151 wantInfo.resolvedTypes = "nihao";
152 allWant.emplace_back(wantInfo);
153 wantSenderInfo.allWants = allWant;
154 wantSenderInfo.flags = flags;
155 wantSenderInfo.userId = userId;
156 return wantSenderInfo;
157 }
158
MakeWantSenderInfo(std::vector<Want> & wants,int32_t flags,int32_t userId,int32_t type)159 WantSenderInfo PendingWantManagerTest::MakeWantSenderInfo(std::vector<Want> &wants,
160 int32_t flags, int32_t userId, int32_t type)
161 {
162 WantSenderInfo wantSenderInfo;
163 wantSenderInfo.type = type;
164 // wantSenderInfo.type is OperationType::START_ABILITY
165 wantSenderInfo.bundleName = "com.ix.hiRadio";
166 wantSenderInfo.resultWho = "RadioTopAbility";
167 int requestCode = 10;
168 wantSenderInfo.requestCode = requestCode;
169 std::vector<WantsInfo> allWant;
170 for (auto want : wants) {
171 WantsInfo wantsInfo;
172 wantsInfo.want = want;
173 wantsInfo.resolvedTypes = "";
174 wantSenderInfo.allWants.push_back(wantsInfo);
175 }
176 wantSenderInfo.flags = flags;
177 wantSenderInfo.userId = userId;
178 return wantSenderInfo;
179 }
180
181
MakeWantKey(WantSenderInfo & wantSenderInfo)182 std::shared_ptr<PendingWantKey> PendingWantManagerTest::MakeWantKey(WantSenderInfo &wantSenderInfo)
183 {
184 std::shared_ptr<PendingWantKey> pendingKey = std::make_shared<PendingWantKey>();
185 pendingKey->SetBundleName(wantSenderInfo.bundleName);
186 pendingKey->SetRequestWho(wantSenderInfo.resultWho);
187 pendingKey->SetRequestCode(wantSenderInfo.requestCode);
188 pendingKey->SetFlags(wantSenderInfo.flags);
189 pendingKey->SetUserId(wantSenderInfo.userId);
190 pendingKey->SetType(wantSenderInfo.type);
191 if (wantSenderInfo.allWants.size() > 0) {
192 pendingKey->SetRequestWant(wantSenderInfo.allWants.back().want);
193 pendingKey->SetRequestResolvedType(wantSenderInfo.allWants.back().resolvedTypes);
194 pendingKey->SetAllWantsInfos(wantSenderInfo.allWants);
195 }
196 return pendingKey;
197 }
198
199 /*
200 * @tc.number : PendingWantManagerTest_0100
201 * @tc.name : PendingWantManager GetWantSender
202 * @tc.desc : 1.GetWantSender function callingUid = 0
203 */
204 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_0100, TestSize.Level1)
205 {
206 int32_t callingUid = 0;
207 int32_t uid = 0;
208 WantSenderInfo wantSenderInfo;
209 wantSenderInfo.flags = 0;
210 pendingManager_ = std::make_shared<PendingWantManager>();
211 EXPECT_NE(pendingManager_, nullptr);
212 EXPECT_NE(pendingManager_->GetWantSender(callingUid, uid, test_apl, wantSenderInfo, nullptr), nullptr);
213 }
214
215 /*
216 * @tc.number : PendingWantManagerTest_0300
217 * @tc.name : PendingWantManager GetWantSender
218 * @tc.desc : 1.GetWantSender function callingUid = 1 && callingUid != uid
219 */
220 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_0300, TestSize.Level1)
221 {
222 int32_t callingUid = 1;
223 int32_t uid = 0;
224 WantSenderInfo wantSenderInfo;
225 wantSenderInfo.flags = 0;
226 pendingManager_ = std::make_shared<PendingWantManager>();
227 EXPECT_NE(pendingManager_, nullptr);
228 EXPECT_NE(pendingManager_->GetWantSender(callingUid, uid, test_apl, wantSenderInfo, nullptr), nullptr);
229 }
230
231 /*
232 * @tc.number : PendingWantManagerTest_0400
233 * @tc.name : PendingWantManager GetWantSender
234 * @tc.desc : 1.GetWantSender function callingUid = 1 && callingUid == uid
235 */
236 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_0400, TestSize.Level1)
237 {
238 int32_t callingUid = 1;
239 int32_t uid = 1;
240 WantSenderInfo wantSenderInfo;
241 wantSenderInfo.flags = 0;
242 pendingManager_ = std::make_shared<PendingWantManager>();
243 EXPECT_NE(pendingManager_, nullptr);
244 EXPECT_NE(pendingManager_->GetWantSender(callingUid, uid, test_apl, wantSenderInfo, nullptr), nullptr);
245 }
246
247 /*
248 * @tc.number : PendingWantManagerTest_0500
249 * @tc.name : PendingWantManager GetWantSenderLocked
250 * @tc.desc : 1.GetWantSenderLocked Flags::NO_BUILD_FLAG
251 */
252 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_0500, TestSize.Level1)
253 {
254 Want want;
255 ElementName element("device", "bundleName", "abilityName");
256 want.SetElement(element);
257 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, static_cast<int32_t>(Flags::NO_BUILD_FLAG), 0);
258 EXPECT_TRUE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
259 pendingManager_ = std::make_shared<PendingWantManager>();
260 EXPECT_NE(pendingManager_, nullptr);
261 EXPECT_EQ(pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr), nullptr);
262 }
263
264 /*
265 * @tc.number : PendingWantManagerTest_0600
266 * @tc.name : PendingWantManager GetWantSenderLocked
267 * @tc.desc : 1.GetWantSenderLocked Flags::ONE_TIME_FLAG ,Creat PendingWantRecord
268 */
269 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_0600, TestSize.Level1)
270 {
271 Want want;
272 ElementName element("device", "bundleName", "abilityName");
273 want.SetElement(element);
274 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
275 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
276 pendingManager_ = std::make_shared<PendingWantManager>();
277 EXPECT_NE(pendingManager_, nullptr);
278 EXPECT_NE(pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr), nullptr);
279 }
280
281 /*
282 * @tc.number : PendingWantManagerTest_0700
283 * @tc.name : PendingWantManager GetWantSenderLocked
284 * @tc.desc : 1.GetWantSenderLocked Flags::NO_BUILD_FLAG ,cancel PendingWantRecord
285 * 2.CANCEL_PRESENT_FLAG means delet existing wantagent before create a new one
286 */
287 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_0700, TestSize.Level1)
288 {
289 Want want;
290 ElementName element("device", "bundleName", "abilityName");
291 want.SetElement(element);
292 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
293 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
294 pendingManager_ = std::make_shared<PendingWantManager>();
295 EXPECT_NE(pendingManager_, nullptr);
296 EXPECT_NE(pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr), nullptr);
297 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
298 WantSenderInfo wantSenderInfo1 = MakeWantSenderInfo(want, static_cast<int32_t>(Flags::CANCEL_PRESENT_FLAG), 0);
299 EXPECT_TRUE(((unsigned int)wantSenderInfo1.flags & (unsigned int)Flags::CANCEL_PRESENT_FLAG) != 0);
300 EXPECT_NE(pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo1.userId, wantSenderInfo1, nullptr), nullptr);
301 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
302 }
303
304 /*
305 * @tc.number : PendingWantManagerTest_0800
306 * @tc.name : PendingWantManager GetWantSenderLocked
307 * @tc.desc : 1.GetWantSenderLocked,Flags::UPDATE_PRESENT_FLAG ,update PendingWantRecord
308 */
309 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_0800, TestSize.Level1)
310 {
311 Want want;
312 ElementName element("device", "bundleName", "abilityName");
313 want.SetElement(element);
314 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
315 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
316 pendingManager_ = std::make_shared<PendingWantManager>();
317 EXPECT_NE(pendingManager_, nullptr);
318 EXPECT_NE(pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr), nullptr);
319 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
320 WantSenderInfo wantSenderInfo1 = MakeWantSenderInfo(want, static_cast<int32_t>(Flags::UPDATE_PRESENT_FLAG), 0);
321 EXPECT_TRUE(((unsigned int)wantSenderInfo1.flags & (unsigned int)Flags::UPDATE_PRESENT_FLAG) != 0);
322 EXPECT_NE(pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo1.userId, wantSenderInfo1, nullptr), nullptr);
323 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
324 }
325
326 /*
327 * @tc.number : PendingWantManagerTest_0900
328 * @tc.name : PendingWantManager GetPendingWantRecordByKey
329 * @tc.desc : 1.GetPendingWantRecordByKey,wantSenderInfo contain want info
330 */
331 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_0900, TestSize.Level1)
332 {
333 Want want;
334 ElementName element("device", "bundleName", "abilityName");
335 want.SetElement(element);
336 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
337 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
338 pendingManager_ = std::make_shared<PendingWantManager>();
339 EXPECT_NE(pendingManager_, nullptr);
340 EXPECT_NE(pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr), nullptr);
341 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
342 std::shared_ptr<PendingWantKey> pendingKey = std::make_shared<PendingWantKey>();
343 pendingKey->SetBundleName(wantSenderInfo.bundleName);
344 pendingKey->SetRequestWho(wantSenderInfo.resultWho);
345 pendingKey->SetRequestCode(wantSenderInfo.requestCode);
346 pendingKey->SetFlags(wantSenderInfo.flags);
347 pendingKey->SetUserId(wantSenderInfo.userId);
348 pendingKey->SetType(wantSenderInfo.type);
349 if (wantSenderInfo.allWants.size() > 0) {
350 pendingKey->SetRequestWant(wantSenderInfo.allWants.back().want);
351 pendingKey->SetRequestResolvedType(wantSenderInfo.allWants.back().resolvedTypes);
352 pendingKey->SetAllWantsInfos(wantSenderInfo.allWants);
353 }
354 EXPECT_NE(pendingManager_->GetPendingWantRecordByKey(pendingKey), nullptr);
355 }
356
357 /*
358 * @tc.number : PendingWantManagerTest_1000
359 * @tc.name : PendingWantManager GetPendingWantRecordByKey
360 * @tc.desc : 1.GetPendingWantRecordByKey,wantSenderInfo not contain want info
361 */
362 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_1000, TestSize.Level1)
363 {
364 Want want;
365 ElementName element("device", "bundleName", "abilityName");
366 want.SetElement(element);
367 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
368 wantSenderInfo.allWants.clear();
369 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
370 pendingManager_ = std::make_shared<PendingWantManager>();
371 EXPECT_NE(pendingManager_, nullptr);
372 EXPECT_NE(pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr), nullptr);
373 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
374 std::shared_ptr<PendingWantKey> pendingKey = std::make_shared<PendingWantKey>();
375 pendingKey->SetBundleName(wantSenderInfo.bundleName);
376 pendingKey->SetRequestWho(wantSenderInfo.resultWho);
377 pendingKey->SetRequestCode(wantSenderInfo.requestCode);
378 pendingKey->SetFlags(wantSenderInfo.flags);
379 pendingKey->SetUserId(wantSenderInfo.userId);
380 pendingKey->SetType(wantSenderInfo.type);
381 if (wantSenderInfo.allWants.size() > 0) {
382 pendingKey->SetRequestWant(wantSenderInfo.allWants.back().want);
383 pendingKey->SetRequestResolvedType(wantSenderInfo.allWants.back().resolvedTypes);
384 pendingKey->SetAllWantsInfos(wantSenderInfo.allWants);
385 }
386 EXPECT_NE(pendingManager_->GetPendingWantRecordByKey(pendingKey), nullptr);
387 }
388
389 /*
390 * @tc.number : PendingWantManagerTest_1100
391 * @tc.name : PendingWantManager GetPendingWantRecordByKey
392 * @tc.desc : 1.GetPendingWantRecordByKey,pendingKey info different wantSenderInfo
393 */
394 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_1100, TestSize.Level1)
395 {
396 Want want;
397 ElementName element("device", "bundleName", "abilityName");
398 want.SetElement(element);
399 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
400 std::shared_ptr<PendingWantKey> pendingKey = std::make_shared<PendingWantKey>();
401 pendingManager_ = std::make_shared<PendingWantManager>();
402 EXPECT_NE(pendingManager_, nullptr);
403 pendingKey->SetBundleName(wantSenderInfo.bundleName + "A");
404 pendingKey->SetRequestWho(wantSenderInfo.resultWho);
405 pendingKey->SetRequestCode(wantSenderInfo.requestCode);
406 pendingKey->SetFlags(wantSenderInfo.flags);
407 pendingKey->SetUserId(wantSenderInfo.userId);
408 pendingKey->SetType(wantSenderInfo.type);
409 if (wantSenderInfo.allWants.size() > 0) {
410 pendingKey->SetRequestWant(wantSenderInfo.allWants.back().want);
411 pendingKey->SetRequestResolvedType(wantSenderInfo.allWants.back().resolvedTypes);
412 pendingKey->SetAllWantsInfos(wantSenderInfo.allWants);
413 }
414 EXPECT_EQ(pendingManager_->GetPendingWantRecordByKey(pendingKey), nullptr);
415 }
416
417 /*
418 * @tc.number : PendingWantManagerTest_1200
419 * @tc.name : PendingWantManager CheckPendingWantRecordByKey
420 * @tc.desc : 1.CheckPendingWantRecordByKey,pendingKey and pendingKey1 is the same
421 */
422 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_1200, TestSize.Level1)
423 {
424 Want want;
425 ElementName element("device", "bundleName", "abilityName");
426 want.SetElement(element);
427 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
428 std::shared_ptr<PendingWantKey> pendingKey = std::make_shared<PendingWantKey>();
429 pendingManager_ = std::make_shared<PendingWantManager>();
430 EXPECT_NE(pendingManager_, nullptr);
431 pendingKey->SetBundleName(wantSenderInfo.bundleName);
432 pendingKey->SetRequestWho(wantSenderInfo.resultWho);
433 pendingKey->SetRequestCode(wantSenderInfo.requestCode);
434 pendingKey->SetFlags(wantSenderInfo.flags);
435 pendingKey->SetUserId(wantSenderInfo.userId);
436 pendingKey->SetType(wantSenderInfo.type);
437 if (wantSenderInfo.allWants.size() > 0) {
438 pendingKey->SetRequestWant(wantSenderInfo.allWants.back().want);
439 pendingKey->SetRequestResolvedType(wantSenderInfo.allWants.back().resolvedTypes);
440 pendingKey->SetAllWantsInfos(wantSenderInfo.allWants);
441 }
442 std::shared_ptr<PendingWantKey> pendingKey1 = std::make_shared<PendingWantKey>();
443 pendingKey1->SetBundleName(wantSenderInfo.bundleName);
444 pendingKey1->SetRequestWho(wantSenderInfo.resultWho);
445 pendingKey1->SetRequestCode(wantSenderInfo.requestCode);
446 pendingKey1->SetFlags(wantSenderInfo.flags);
447 pendingKey1->SetUserId(wantSenderInfo.userId);
448 pendingKey1->SetType(wantSenderInfo.type);
449 if (wantSenderInfo.allWants.size() > 0) {
450 pendingKey1->SetRequestWant(wantSenderInfo.allWants.back().want);
451 pendingKey1->SetRequestResolvedType(wantSenderInfo.allWants.back().resolvedTypes);
452 pendingKey1->SetAllWantsInfos(wantSenderInfo.allWants);
453 }
454 EXPECT_EQ(pendingManager_->CheckPendingWantRecordByKey(pendingKey, pendingKey1), true);
455 }
456
457 /*
458 * @tc.number : PendingWantManagerTest_1300
459 * @tc.name : PendingWantManager CheckPendingWantRecordByKey
460 * @tc.desc : 1.CheckPendingWantRecordByKey,pendingKey and pendingKey1 is the different
461 */
462 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_1300, TestSize.Level1)
463 {
464 Want want;
465 ElementName element("device", "bundleName", "abilityName");
466 want.SetElement(element);
467 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
468 WantSenderInfo wantSenderInfo1 = MakeWantSenderInfo(want, 0, 1);
469 pendingManager_ = std::make_shared<PendingWantManager>();
470 std::shared_ptr<PendingWantKey> pendingKey = std::make_shared<PendingWantKey>();
471 EXPECT_NE(pendingManager_, nullptr);
472 pendingKey->SetBundleName(wantSenderInfo.bundleName);
473 pendingKey->SetRequestWho(wantSenderInfo.resultWho);
474 pendingKey->SetRequestCode(wantSenderInfo.requestCode);
475 pendingKey->SetFlags(wantSenderInfo.flags);
476 pendingKey->SetUserId(wantSenderInfo.userId);
477 pendingKey->SetType(wantSenderInfo.type);
478 if (wantSenderInfo.allWants.size() > 0) {
479 pendingKey->SetRequestWant(wantSenderInfo.allWants.back().want);
480 pendingKey->SetRequestResolvedType(wantSenderInfo.allWants.back().resolvedTypes);
481 pendingKey->SetAllWantsInfos(wantSenderInfo.allWants);
482 }
483 std::shared_ptr<PendingWantKey> pendingKey1 = std::make_shared<PendingWantKey>();
484 pendingKey1->SetBundleName(wantSenderInfo1.bundleName);
485 pendingKey1->SetRequestWho(wantSenderInfo1.resultWho);
486 pendingKey1->SetRequestCode(wantSenderInfo1.requestCode);
487 pendingKey1->SetFlags(wantSenderInfo1.flags);
488 pendingKey1->SetUserId(wantSenderInfo1.userId);
489 pendingKey1->SetType(wantSenderInfo1.type);
490 if (wantSenderInfo1.allWants.size() > 0) {
491 pendingKey1->SetRequestWant(wantSenderInfo1.allWants.back().want);
492 pendingKey1->SetRequestResolvedType(wantSenderInfo1.allWants.back().resolvedTypes);
493 pendingKey1->SetAllWantsInfos(wantSenderInfo1.allWants);
494 }
495 EXPECT_EQ(pendingManager_->CheckPendingWantRecordByKey(pendingKey, pendingKey1), false);
496 }
497
498 /*
499 * @tc.number : PendingWantManagerTest_1400
500 * @tc.name : PendingWantManager SendWantSender
501 * @tc.desc : 1.SendWantSender,call the function(PerformReceive) of the callback class
502 */
503 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_1400, TestSize.Level1)
504 {
505 Want want;
506 ElementName element("device", "com.ix.hiMusic", "MusicSAbility");
507 want.SetElement(element);
508 WantSenderInfo wantSenderInfo =
509 MakeWantSenderInfo(want, (int32_t)Flags::CONSTANT_FLAG, 0, (int32_t)OperationType::SEND_COMMON_EVENT);
510 pendingManager_ = std::make_shared<PendingWantManager>();
511 EXPECT_NE(pendingManager_, nullptr);
512 std::shared_ptr<PendingWantKey> key = MakeWantKey(wantSenderInfo);
513 sptr<PendingWantRecord> pendingWantRecord = new PendingWantRecord(pendingManager_, 1, 0, nullptr, key);
514 EXPECT_NE(pendingWantRecord, nullptr);
515 SenderInfo info;
516 info.finishedReceiver = new CancelReceiver();
517 EXPECT_EQ(pendingManager_->SendWantSender(pendingWantRecord, info), -1);
518 EXPECT_TRUE(CancelReceiver::performReceiveCount == 100);
519 CancelReceiver::performReceiveCount = 0;
520 }
521
522 /*
523 * @tc.number : PendingWantManagerTest_1500
524 * @tc.name : PendingWantManager GetPendingWantRecordByCode
525 * @tc.desc : 1.GetPendingWantRecordByCode,parameter not nullptr
526 */
527 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_1500, TestSize.Level1)
528 {
529 Want want;
530 ElementName element("device", "bundleName", "abilityName");
531 want.SetElement(element);
532 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
533 wantSenderInfo.allWants.clear();
534 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
535 pendingManager_ = std::make_shared<PendingWantManager>();
536 EXPECT_NE(pendingManager_, nullptr);
537 auto pendingRecord = pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr);
538 EXPECT_NE(pendingRecord, nullptr);
539 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
540 EXPECT_NE(pendingManager_->GetPendingWantRecordByCode(pendingManager_->GetPendingWantCode(pendingRecord)), nullptr);
541 }
542
543 /*
544 * @tc.number : PendingWantManagerTest_1600
545 * @tc.name : PendingWantManager GetPendingWantRecordByCode
546 * @tc.desc : 1.GetPendingWantRecordByCode,no pendingWantRecord
547 */
548 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_1600, TestSize.Level1)
549 {
550 pendingManager_ = std::make_shared<PendingWantManager>();
551 EXPECT_NE(pendingManager_, nullptr);
552 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 0);
553 EXPECT_EQ(pendingManager_->GetPendingWantRecordByCode(1), nullptr);
554 }
555
556 /*
557 * @tc.number : PendingWantManagerTest_1700
558 * @tc.name : PendingWantManager GetPendingWantRecordByCode
559 * @tc.desc : 1.GetPendingWantRecordByCode,parameter not nullptr
560 */
561 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_1700, TestSize.Level1)
562 {
563 Want want;
564 ElementName element("device", "bundleName", "abilityName");
565 want.SetElement(element);
566 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
567 wantSenderInfo.allWants.clear();
568 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
569 pendingManager_ = std::make_shared<PendingWantManager>();
570 EXPECT_NE(pendingManager_, nullptr);
571 EXPECT_NE(pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr), nullptr);
572 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
573 EXPECT_EQ(pendingManager_->GetPendingWantRecordByCode(100), nullptr);
574 }
575
576 /*
577 * @tc.number : PendingWantManagerTest_1800
578 * @tc.name : PendingWantManager GetPendingWantUid
579 * @tc.desc : 1.GetPendingWantUid, parameter nullptr
580 */
581 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_1800, TestSize.Level1)
582 {
583 pendingManager_ = std::make_shared<PendingWantManager>();
584 EXPECT_NE(pendingManager_, nullptr);
585 EXPECT_EQ(pendingManager_->GetPendingWantUid(nullptr), -1);
586 }
587
588 /*
589 * @tc.number : PendingWantManagerTest_1900
590 * @tc.name : PendingWantManager GetPendingWantUid
591 * @tc.desc : 1.GetPendingWantUid, parameter not nullptr
592 */
593 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_1900, TestSize.Level1)
594 {
595 Want want;
596 ElementName element("device", "bundleName", "abilityName");
597 want.SetElement(element);
598 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
599 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
600 pendingManager_ = std::make_shared<PendingWantManager>();
601 EXPECT_NE(pendingManager_, nullptr);
602 auto pendingRecord = pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr);
603 EXPECT_NE(pendingRecord, nullptr);
604 EXPECT_EQ(pendingManager_->GetPendingWantUid(pendingRecord), 1);
605 }
606
607 /*
608 * @tc.number : PendingWantManagerTest_2000
609 * @tc.name : PendingWantManager GetPendingWantUserId
610 * @tc.desc : 1.GetPendingWantUserId, parameter nullptr
611 */
612 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_2000, TestSize.Level1)
613 {
614 pendingManager_ = std::make_shared<PendingWantManager>();
615 EXPECT_NE(pendingManager_, nullptr);
616 EXPECT_EQ(pendingManager_->GetPendingWantUserId(nullptr), -1);
617 }
618
619 /*
620 * @tc.number : PendingWantManagerTest_2100
621 * @tc.name : PendingWantManager GetPendingWantUserId
622 * @tc.desc : 1.GetPendingWantUserId,parameter not nullptr
623 */
624 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_2100, TestSize.Level1)
625 {
626 Want want;
627 ElementName element("device", "bundleName", "abilityName");
628 want.SetElement(element);
629 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
630 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
631 pendingManager_ = std::make_shared<PendingWantManager>();
632 EXPECT_NE(pendingManager_, nullptr);
633 auto pendingRecord = pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr);
634 EXPECT_NE(pendingRecord, nullptr);
635 EXPECT_EQ(pendingManager_->GetPendingWantUserId(pendingRecord), 0);
636 }
637
638 /*
639 * @tc.number : PendingWantManagerTest_2200
640 * @tc.name : PendingWantManager GetPendingWantBundleName
641 * @tc.desc : 1.GetPendingWantBundleName, parameter nullptr
642 */
643 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_2200, TestSize.Level1)
644 {
645 pendingManager_ = std::make_shared<PendingWantManager>();
646 EXPECT_NE(pendingManager_, nullptr);
647 EXPECT_EQ(pendingManager_->GetPendingWantBundleName(nullptr), "");
648 }
649
650 /*
651 * @tc.number : PendingWantManagerTest_2300
652 * @tc.name : PendingWantManager GetPendingWantBundleName
653 * @tc.desc : 1.GetPendingWantBundleName, parameter not nullptr
654 */
655 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_2300, TestSize.Level1)
656 {
657 Want want;
658 ElementName element("device", "bundleName", "abilityName");
659 want.SetElement(element);
660 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
661 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
662 pendingManager_ = std::make_shared<PendingWantManager>();
663 EXPECT_NE(pendingManager_, nullptr);
664 auto pendingRecord = pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr);
665 EXPECT_NE(pendingRecord, nullptr);
666 EXPECT_EQ(pendingManager_->GetPendingWantBundleName(pendingRecord), "com.ix.hiRadio");
667 }
668
669 /*
670 * @tc.number : PendingWantManagerTest_2400
671 * @tc.name : PendingWantManager GetPendingWantCode
672 * @tc.desc : 1.GetPendingWantCode, parameter nullptr
673 */
674 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_2400, TestSize.Level1)
675 {
676 pendingManager_ = std::make_shared<PendingWantManager>();
677 EXPECT_NE(pendingManager_, nullptr);
678 EXPECT_EQ(pendingManager_->GetPendingWantCode(nullptr), -1);
679 }
680
681 /*
682 * @tc.number : PendingWantManagerTest_2500
683 * @tc.name : PendingWantManager GetPendingWantCode
684 * @tc.desc : 1.GetPendingWantCode, parameter not nullptr
685 */
686 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_2500, TestSize.Level1)
687 {
688 Want want;
689 ElementName element("device", "bundleName", "abilityName");
690 want.SetElement(element);
691 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
692 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
693 pendingManager_ = std::make_shared<PendingWantManager>();
694 EXPECT_NE(pendingManager_, nullptr);
695 auto pendingRecord = pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr);
696 EXPECT_NE(pendingRecord, nullptr);
697 EXPECT_TRUE(pendingManager_->GetPendingWantCode(pendingRecord) != -1);
698 }
699
700 /*
701 * @tc.number : PendingWantManagerTest_2600
702 * @tc.name : PendingWantManager GetPendingWantType
703 * @tc.desc : 1.GetPendingWantType, parameter nullptr
704 */
705 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_2600, TestSize.Level1)
706 {
707 pendingManager_ = std::make_shared<PendingWantManager>();
708 EXPECT_NE(pendingManager_, nullptr);
709 EXPECT_EQ(pendingManager_->GetPendingWantType(nullptr), -1);
710 }
711
712 /*
713 * @tc.number : PendingWantManagerTest_2700
714 * @tc.name : PendingWantManager GetPendingWantType
715 * @tc.desc : 1.GetPendingWantType, parameter not nullptr
716 */
717 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_2700, TestSize.Level1)
718 {
719 Want want;
720 ElementName element("device", "bundleName", "abilityName");
721 want.SetElement(element);
722 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
723 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
724 pendingManager_ = std::make_shared<PendingWantManager>();
725 EXPECT_NE(pendingManager_, nullptr);
726 auto pendingRecord = pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr);
727 EXPECT_NE(pendingRecord, nullptr);
728 EXPECT_TRUE(pendingManager_->GetPendingWantType(pendingRecord) != -1);
729 }
730
731 /*
732 * @tc.number : PendingWantManagerTest_2800
733 * @tc.name : PendingWantManager RegisterCancelListener
734 * @tc.desc : 1.RegisterCancelListener,Canceled == false
735 */
736 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_2800, TestSize.Level1)
737 {
738 sptr<CancelReceiver> cance = new CancelReceiver();
739 Want want;
740 ElementName element("device", "bundleName", "abilityName");
741 want.SetElement(element);
742 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
743 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
744 pendingManager_ = std::make_shared<PendingWantManager>();
745 EXPECT_NE(pendingManager_, nullptr);
746 auto pendingRecord = iface_cast<PendingWantRecord>(
747 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr)->AsObject());
748 EXPECT_NE(pendingRecord, nullptr);
749 pendingManager_->RegisterCancelListener(pendingRecord, cance);
750 EXPECT_EQ(static_cast<int>(pendingRecord->GetCancelCallbacks().size()), 1);
751 }
752
753 /*
754 * @tc.number : PendingWantManagerTest_2900
755 * @tc.name : PendingWantManager RegisterCancelListener
756 * @tc.desc : 1.RegisterCancelListener,Canceled == true
757 */
758 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_2900, TestSize.Level1)
759 {
760 sptr<CancelReceiver> cance = new CancelReceiver();
761 Want want;
762 ElementName element("device", "bundleName", "abilityName");
763 want.SetElement(element);
764 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
765 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
766 pendingManager_ = std::make_shared<PendingWantManager>();
767 EXPECT_NE(pendingManager_, nullptr);
768 auto pendingRecord = iface_cast<PendingWantRecord>(
769 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr)->AsObject());
770 EXPECT_NE(pendingRecord, nullptr);
771 pendingRecord->SetCanceled();
772 pendingManager_->RegisterCancelListener(pendingRecord, cance);
773 EXPECT_EQ(static_cast<int>(pendingRecord->GetCancelCallbacks().size()), 0);
774 }
775
776 /*
777 * @tc.number : PendingWantManagerTest_3000
778 * @tc.name : PendingWantManager UnregisterCancelListener
779 * @tc.desc : 1.UnregisterCancelListener
780 */
781 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_3000, TestSize.Level1)
782 {
783 sptr<CancelReceiver> cance = new CancelReceiver();
784 Want want;
785 ElementName element("device", "bundleName", "abilityName");
786 want.SetElement(element);
787 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
788 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
789 pendingManager_ = std::make_shared<PendingWantManager>();
790 EXPECT_NE(pendingManager_, nullptr);
791 auto pendingRecord = iface_cast<PendingWantRecord>(
792 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr)->AsObject());
793 EXPECT_NE(pendingRecord, nullptr);
794 pendingManager_->RegisterCancelListener(pendingRecord, cance);
795 EXPECT_EQ(static_cast<int>(pendingRecord->GetCancelCallbacks().size()), 1);
796 pendingManager_->UnregisterCancelListener(pendingRecord, cance);
797 EXPECT_EQ(static_cast<int>(pendingRecord->GetCancelCallbacks().size()), 0);
798 }
799
800 /*
801 * @tc.number : PendingWantManagerTest_3100
802 * @tc.name : PendingWantManager CancelWantSender
803 * @tc.desc : 1.CancelWantSender,,call the function(Send) of the callback class
804 */
805 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_3100, TestSize.Level1)
806 {
807 sptr<CancelReceiver> cance = new CancelReceiver();
808 Want want;
809 ElementName element("device", "bundleName", "abilityName");
810 want.SetElement(element);
811 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
812 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
813 pendingManager_ = std::make_shared<PendingWantManager>();
814 EXPECT_NE(pendingManager_, nullptr);
815 auto pendingRecord = iface_cast<PendingWantRecord>(
816 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr)->AsObject());
817 EXPECT_NE(pendingRecord, nullptr);
818 pendingManager_->RegisterCancelListener(pendingRecord, cance);
819 std::string testApl = "";
820 pendingManager_->CancelWantSender(testApl, pendingRecord);
821 EXPECT_TRUE(CancelReceiver::sendCount == 100);
822 EXPECT_TRUE((int)pendingManager_->wantRecords_.size() == 0);
823 }
824
825 /*
826 * @tc.number : PendingWantManagerTest_3200
827 * @tc.name : PendingWantManager GetPendingRequestWant
828 * @tc.desc : 1.GetPendingRequestWant, Get pendingRecord want object.
829 */
830 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_3200, TestSize.Level1)
831 {
832 Want want;
833 ElementName element("device", "bundleName", "abilityName");
834 want.SetElement(element);
835 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
836 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
837 pendingManager_ = std::make_shared<PendingWantManager>();
838 EXPECT_NE(pendingManager_, nullptr);
839 auto pendingRecord = iface_cast<PendingWantRecord>(
840 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr)->AsObject());
841 EXPECT_NE(pendingRecord, nullptr);
842 std::shared_ptr<Want> getWantInfo = std::make_shared<Want>();
843 EXPECT_EQ(pendingManager_->GetPendingRequestWant(pendingRecord, getWantInfo), NO_ERROR);
844 EXPECT_EQ(getWantInfo->GetElement().GetBundleName(), "bundleName");
845 EXPECT_EQ(getWantInfo->GetElement().GetAbilityName(), "abilityName");
846 }
847
848 /*
849 * @tc.number : PendingWantManagerTest_3300
850 * @tc.name : PendingWantManager GetPendingRequestWant
851 * @tc.desc : 1.GetPendingRequestWant, Get pendingRecord want object,pendingRecord is nullptr.
852 */
853 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_3300, TestSize.Level1)
854 {
855 Want want;
856 ElementName element("device", "bundleName", "abilityName");
857 want.SetElement(element);
858 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
859 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
860 pendingManager_ = std::make_shared<PendingWantManager>();
861 EXPECT_NE(pendingManager_, nullptr);
862 auto pendingRecord = iface_cast<PendingWantRecord>(
863 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr)->AsObject());
864 EXPECT_NE(pendingRecord, nullptr);
865 std::shared_ptr<Want> getWantInfo = std::make_shared<Want>();
866 EXPECT_EQ(pendingManager_->GetPendingRequestWant(nullptr, getWantInfo), ERR_INVALID_VALUE);
867 }
868
869 /*
870 * @tc.number : PendingWantManagerTest_3400
871 * @tc.name : PendingWantManager GetPendingRequestWant
872 * @tc.desc : 1.GetPendingRequestWant, Get pendingRecord want object,want is nullptr.
873 */
874 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_3400, TestSize.Level1)
875 {
876 Want want;
877 ElementName element("device", "bundleName", "abilityName");
878 want.SetElement(element);
879 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0);
880 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
881 pendingManager_ = std::make_shared<PendingWantManager>();
882 EXPECT_NE(pendingManager_, nullptr);
883 auto pendingRecord = iface_cast<PendingWantRecord>(
884 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr)->AsObject());
885 EXPECT_NE(pendingRecord, nullptr);
886 std::shared_ptr<Want> getWantInfo;
887 EXPECT_EQ(pendingManager_->GetPendingRequestWant(pendingRecord, getWantInfo), ERR_INVALID_VALUE);
888 }
889
890 /*
891 * @tc.number : PendingWantManagerTest_3500
892 * @tc.name : PendingWantManager ClearPendingWantRecordTask
893 * @tc.desc : 1.ClearPendingWantRecordTask.
894 */
895 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_3500, TestSize.Level1)
896 {
897 Want want1;
898 ElementName element("device", "bundleName1", "abilityName1");
899 want1.SetElement(element);
900 Want want2;
901 ElementName element2("device", "bundleName2", "abilityName2");
902 want2.SetElement(element2);
903 std::vector<Want> wants;
904 wants.emplace_back(want1);
905 wants.emplace_back(want2);
906 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(wants, 0, 0);
907 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
908 pendingManager_ = std::make_shared<PendingWantManager>();
909 EXPECT_NE(pendingManager_, nullptr);
910 auto pendingRecord = iface_cast<PendingWantRecord>(
911 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr)->AsObject());
912 EXPECT_NE(pendingRecord, nullptr);
913 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
914 Want want3;
915 ElementName element3("device", "bundleName2", "abilityName2");
916 want3.SetElement(element3);
917 WantSenderInfo wantSenderInfo1 = MakeWantSenderInfo(want3, 0, 0);
918 EXPECT_FALSE(((unsigned int)wantSenderInfo1.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
919 auto pendingRecord1 = iface_cast<PendingWantRecord>(
920 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo1.userId, wantSenderInfo1, nullptr)->AsObject());
921 EXPECT_NE(pendingRecord1, nullptr);
922 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 2);
923 pendingManager_->ClearPendingWantRecordTask("bundleName2", 1);
924 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 0);
925 }
926
927 /*
928 * @tc.number : PendingWantManagerTest_3600
929 * @tc.name : PendingWantManager ClearPendingWantRecordTask
930 * @tc.desc : 1.ClearPendingWantRecordTask.
931 */
932 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_3600, TestSize.Level1)
933 {
934 Want want1;
935 ElementName element("device", "bundleName1", "abilityName1");
936 want1.SetElement(element);
937 Want want2;
938 ElementName element2("device", "bundleName2", "abilityName2");
939 want2.SetElement(element2);
940 std::vector<Want> wants;
941 wants.emplace_back(want1);
942 wants.emplace_back(want2);
943 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(wants, 0, 0);
944 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
945 pendingManager_ = std::make_shared<PendingWantManager>();
946 EXPECT_NE(pendingManager_, nullptr);
947 auto pendingRecord = iface_cast<PendingWantRecord>(
948 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr)->AsObject());
949 EXPECT_NE(pendingRecord, nullptr);
950 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
951 Want want3;
952 ElementName element3("device", "bundleName2", "abilityName2");
953 want3.SetElement(element3);
954 WantSenderInfo wantSenderInfo1 = MakeWantSenderInfo(want3, 0, 0);
955 EXPECT_FALSE(((unsigned int)wantSenderInfo1.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
956 auto pendingRecord1 = iface_cast<PendingWantRecord>(
957 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo1.userId, wantSenderInfo1, nullptr)->AsObject());
958 EXPECT_NE(pendingRecord1, nullptr);
959 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 2);
960 pendingManager_->ClearPendingWantRecordTask("bundleName1", 1);
961 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
962 }
963
964 /*
965 * @tc.number : PendingWantManagerTest_3700
966 * @tc.name : PendingWantManager ClearPendingWantRecordTask
967 * @tc.desc : 1.ClearPendingWantRecordTask.
968 */
969 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_3700, TestSize.Level1)
970 {
971 Want want1;
972 ElementName element("device", "bundleName1", "abilityName1");
973 want1.SetElement(element);
974 Want want2;
975 ElementName element2("device", "bundleName2", "abilityName2");
976 want2.SetElement(element2);
977 std::vector<Want> wants;
978 wants.emplace_back(want1);
979 wants.emplace_back(want2);
980 WantSenderInfo wantSenderInfo = MakeWantSenderInfo(wants, 0, 0);
981 EXPECT_FALSE(((unsigned int)wantSenderInfo.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
982 pendingManager_ = std::make_shared<PendingWantManager>();
983 EXPECT_NE(pendingManager_, nullptr);
984 auto pendingRecord = iface_cast<PendingWantRecord>(
985 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo.userId, wantSenderInfo, nullptr)->AsObject());
986 EXPECT_NE(pendingRecord, nullptr);
987 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 1);
988 Want want3;
989 ElementName element3("device", "bundleName2", "abilityName2");
990 want3.SetElement(element3);
991 WantSenderInfo wantSenderInfo1 = MakeWantSenderInfo(want3, 0, 0);
992 EXPECT_FALSE(((unsigned int)wantSenderInfo1.flags & (unsigned int)Flags::NO_BUILD_FLAG) != 0);
993 auto pendingRecord1 = iface_cast<PendingWantRecord>(
994 pendingManager_->GetWantSenderLocked(1, 1, wantSenderInfo1.userId, wantSenderInfo1, nullptr)->AsObject());
995 EXPECT_NE(pendingRecord1, nullptr);
996 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 2);
997 pendingManager_->ClearPendingWantRecordTask("bundleName3", 1);
998 EXPECT_EQ((int)pendingManager_->wantRecords_.size(), 2);
999 }
1000
1001 /*
1002 * Feature: PendingWantManager
1003 * Function: PendingWantStartAbility
1004 * SubFunction: NA
1005 * FunctionPoints: PendingWant Start Ability
1006 * EnvConditions: NA
1007 * CaseDescription: PendingWantStartAbility, DeviceID isn't null, a single Want, callerUid is -1.
1008 */
1009 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_3900, TestSize.Level1)
1010 {
1011 int32_t callerUid = -1;
1012 Want want;
1013 ElementName element("device", "bundleName1", "abilityName1");
1014 want.SetElement(element);
1015 auto result = abilityMs_->pendingWantManager_->PendingWantStartAbility(want, nullptr, -1, callerUid);
1016 EXPECT_NE(ERR_OK, result);
1017 }
1018
1019 /*
1020 * Feature: PendingWantManager
1021 * Function: PendingWantStartAbilitys
1022 * SubFunction: NA
1023 * FunctionPoints: PendingWant Start Abilitys
1024 * EnvConditions: NA
1025 * CaseDescription: PendingWantStartAbilitys, DeviceID isn't null, multiple Want, callerUid is -1.
1026 */
1027 HWTEST_F(PendingWantManagerTest, PendingWantManagerTest_4100, TestSize.Level1)
1028 {
1029 int32_t callerUid = -1;
1030 WantsInfo wantsInfo;
1031 Want want;
1032 ElementName element("device", "bundleName", "abilityName");
1033 want.SetElement(element);
1034 wantsInfo.want = want;
1035 WantsInfo wantsInfo1;
1036 Want want1;
1037 ElementName element1("device", "bundleName1", "abilityName1");
1038 want1.SetElement(element1);
1039 wantsInfo1.want = want1;
1040 std::vector<WantsInfo> wnatsInfos;
1041 wnatsInfos.emplace_back(wantsInfo);
1042 wnatsInfos.emplace_back(wantsInfo1);
1043 auto result = abilityMs_->pendingWantManager_->PendingWantStartAbilitys(wnatsInfos,
1044 nullptr, -1, callerUid);
1045 EXPECT_NE(ERR_OK, result);
1046 }
1047 } // namespace AAFwk
1048 } // namespace OHOS
1049