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