1 /*
2 * Copyright (c) 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 <chrono>
17 #include <thread>
18 #include <iremote_broker.h>
19 #include "gtest/gtest.h"
20
21 #include "bgtaskmgr_inner_errors.h"
22 #include "background_mode.h"
23 #include "background_task_mgr_helper.h"
24 #include "background_task_subscriber.h"
25 #include "background_task_subscriber_stub.h"
26 #include "continuous_task_callback_info.h"
27 #include "continuous_task_param.h"
28 #include "delay_suspend_info.h"
29 #include "efficiency_resource_info.h"
30 #include "expired_callback.h"
31 #include "ibackground_task_mgr.h"
32 #include "resource_callback_info.h"
33 #include "resource_type.h"
34 #include "transient_task_app_info.h"
35
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace BackgroundTaskMgr {
40 namespace {
41 constexpr int32_t DATA_TRANSFER_ID = 1;
42 constexpr int32_t AUDIO_PLAYBACK_ID = 2;
43 constexpr int32_t AUDIO_RECORDING_ID = 3;
44 constexpr int32_t LOCATION_ID = 4;
45 constexpr int32_t BLUETOOTH_INTERACTION_ID = 5;
46 constexpr int32_t MULTI_DEVICE_CONNECTION_ID = 6;
47 constexpr int32_t WIFI_INTERACTION_ID = 7;
48 constexpr int32_t VOIP_ID = 8;
49 constexpr int32_t TASK_KEEPING_ID = 9;
50 constexpr int32_t SLEEP_TIME = 500;
51 constexpr uint32_t CPU_TYPE = 1;
52 constexpr uint32_t COMMON_EVENT_TYPE = 2;
53 constexpr uint32_t TIMER_TYPE = 4;
54 constexpr uint32_t WORK_SCHEDULER_TYPE = 8;
55 constexpr uint32_t BLUETOOTH_TYPE = 16;
56 constexpr uint32_t GPS_TYPE = 32;
57 constexpr uint32_t AUDIO_TYPE = 64;
58 constexpr uint32_t RUNNING_LOCK = 128;
59 constexpr uint32_t SENSOR = 256;
60 }
61 class BgTaskClientUnitTest : public testing::Test {
62 public:
63 static void SetUpTestCase();
64 static void TearDownTestCase();
65 void SetUp() override;
66 void TearDown() override;
SleepForFC()67 inline void SleepForFC()
68 {
69 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME));
70 }
71
72 std::shared_ptr<BackgroundTaskSubscriber> subscriber_ {nullptr};
73 static std::string bgtaskSubscriberRet_;
74 static std::string expiredCallbackRet_;
75 };
76
77 std::string BgTaskClientUnitTest::bgtaskSubscriberRet_ {""};
78 std::string BgTaskClientUnitTest::expiredCallbackRet_ {""};
79
SetUpTestCase()80 void BgTaskClientUnitTest::SetUpTestCase() {}
81
TearDownTestCase()82 void BgTaskClientUnitTest::TearDownTestCase() {}
83
SetUp()84 void BgTaskClientUnitTest::SetUp() {}
85
TearDown()86 void BgTaskClientUnitTest::TearDown() {}
87
88 class TestBackgroundTaskSubscriber : public BackgroundTaskSubscriber {
89 public:
TestBackgroundTaskSubscriber()90 TestBackgroundTaskSubscriber() : BackgroundTaskSubscriber() {}
91
OnConnected()92 void OnConnected() override
93 {
94 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface1";
95 }
96
OnDisconnected()97 void OnDisconnected() override
98 {
99 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface2";
100 }
101
OnTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo> & info)102 void OnTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo>& info) override
103 {
104 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface3";
105 }
106
OnTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo> & info)107 void OnTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo>& info) override
108 {
109 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface4";
110 }
111
OnTransientTaskErr(const std::shared_ptr<TransientTaskAppInfo> & info)112 void OnTransientTaskErr(const std::shared_ptr<TransientTaskAppInfo>& info) override
113 {
114 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface16";
115 }
116
OnAppTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo> & info)117 void OnAppTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo>& info) override
118 {
119 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface5";
120 }
121
OnAppTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo> & info)122 void OnAppTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo>& info) override
123 {
124 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface6";
125 }
126
OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)127 void OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo>
128 &continuousTaskCallbackInfo) override
129 {
130 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface7";
131 }
132
OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)133 void OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo>
134 &continuousTaskCallbackInfo) override
135 {
136 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface8";
137 }
138
OnAppContinuousTaskStop(int32_t uid)139 void OnAppContinuousTaskStop(int32_t uid) override
140 {
141 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface9";
142 }
143
OnRemoteDied(const wptr<IRemoteObject> & object)144 void OnRemoteDied(const wptr<IRemoteObject> &object) override
145 {
146 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface10";
147 }
148
OnAppEfficiencyResourcesApply(const std::shared_ptr<ResourceCallbackInfo> & resourceInfo)149 void OnAppEfficiencyResourcesApply(const std::shared_ptr<ResourceCallbackInfo> &resourceInfo) override
150 {
151 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface11";
152 }
153
OnAppEfficiencyResourcesReset(const std::shared_ptr<ResourceCallbackInfo> & resourceInfo)154 void OnAppEfficiencyResourcesReset(const std::shared_ptr<ResourceCallbackInfo> &resourceInfo) override
155 {
156 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface12";
157 }
158
OnProcEfficiencyResourcesApply(const std::shared_ptr<ResourceCallbackInfo> & resourceInfo)159 void OnProcEfficiencyResourcesApply(const std::shared_ptr<ResourceCallbackInfo> &resourceInfo) override
160 {
161 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface13";
162 }
163
OnProcEfficiencyResourcesReset(const std::shared_ptr<ResourceCallbackInfo> & resourceInfo)164 void OnProcEfficiencyResourcesReset(const std::shared_ptr<ResourceCallbackInfo> &resourceInfo) override
165 {
166 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface14";
167 }
168
OnContinuousTaskUpdate(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)169 void OnContinuousTaskUpdate(const std::shared_ptr<ContinuousTaskCallbackInfo>
170 &continuousTaskCallbackInfo) override
171 {
172 BgTaskClientUnitTest::bgtaskSubscriberRet_ = "interface15";
173 }
174 };
175
176 class TestExpiredCallback : public ExpiredCallback {
177 public:
TestExpiredCallback()178 TestExpiredCallback() : ExpiredCallback() {}
179
OnExpired()180 void OnExpired() override
181 {
182 BgTaskClientUnitTest::expiredCallbackRet_ = "OnExpired";
183 }
184 };
185
186 /**
187 * @tc.name: BackgroundMode_001
188 * @tc.desc: test background mode constant.
189 * @tc.type: FUNC
190 * @tc.require: issueI5IRJK
191 */
192 HWTEST_F(BgTaskClientUnitTest, BackgroundMode_001, TestSize.Level1)
193 {
194 EXPECT_EQ(DATA_TRANSFER_ID, (int32_t)BackgroundMode::DATA_TRANSFER);
195 EXPECT_EQ(AUDIO_PLAYBACK_ID, (int32_t)BackgroundMode::AUDIO_PLAYBACK);
196 EXPECT_EQ(AUDIO_RECORDING_ID, (int32_t)BackgroundMode::AUDIO_RECORDING);
197 EXPECT_EQ(LOCATION_ID, (int32_t)BackgroundMode::LOCATION);
198 EXPECT_EQ(BLUETOOTH_INTERACTION_ID, (int32_t)BackgroundMode::BLUETOOTH_INTERACTION);
199 EXPECT_EQ(MULTI_DEVICE_CONNECTION_ID, (int32_t)BackgroundMode::MULTI_DEVICE_CONNECTION);
200 EXPECT_EQ(WIFI_INTERACTION_ID, (int32_t)BackgroundMode::WIFI_INTERACTION);
201 EXPECT_EQ(VOIP_ID, (int32_t)BackgroundMode::VOIP);
202 EXPECT_EQ(TASK_KEEPING_ID, (int32_t)BackgroundMode::TASK_KEEPING);
203 }
204
205 /**
206 * @tc.name: RequestStartBackgroundRunning_001
207 * @tc.desc: test RequestStartBackgroundRunning interface.
208 * @tc.type: FUNC
209 * @tc.require: issueI5IRJK
210 */
211 HWTEST_F(BgTaskClientUnitTest, RequestStartBackgroundRunning_001, TestSize.Level1)
212 {
213 ContinuousTaskParam taskParam = ContinuousTaskParam();
214 EXPECT_NE(BackgroundTaskMgrHelper::RequestStartBackgroundRunning(taskParam), ERR_OK);
215 }
216
217 /**
218 * @tc.name: RequestUpdateBackgroundRunning_001
219 * @tc.desc: test RequestUpdateBackgroundRunning interface.
220 * @tc.type: FUNC
221 * @tc.require: issueI94UH9
222 */
223 HWTEST_F(BgTaskClientUnitTest, RequestUpdateBackgroundRunning_001, TestSize.Level1)
224 {
225 ContinuousTaskParam taskParam = ContinuousTaskParam();
226 EXPECT_NE(BackgroundTaskMgrHelper::RequestUpdateBackgroundRunning(taskParam), ERR_OK);
227 }
228
229 /**
230 * @tc.name: RequestStopBackgroundRunning_001
231 * @tc.desc: test RequestStopBackgroundRunning interface.
232 * @tc.type: FUNC
233 * @tc.require: issueI5IRJK issueI99HSB
234 */
235 HWTEST_F(BgTaskClientUnitTest, RequestStopBackgroundRunning_001, TestSize.Level1)
236 {
237 EXPECT_NE(BackgroundTaskMgrHelper::RequestStopBackgroundRunning("test", nullptr, -1), ERR_OK);
238 }
239
240 /**
241 * @tc.name: RequestBackgroundRunningForInner_001
242 * @tc.desc: test RequestBackgroundRunningForInner interface.
243 * @tc.type: FUNC
244 * @tc.require: issueI5IRJK
245 */
246 HWTEST_F(BgTaskClientUnitTest, RequestBackgroundRunningForInner_001, TestSize.Level1)
247 {
248 ContinuousTaskParamForInner taskParam = ContinuousTaskParamForInner();
249 EXPECT_NE(BackgroundTaskMgrHelper::RequestBackgroundRunningForInner(taskParam), ERR_OK);
250 }
251
252 /**
253 * @tc.name: SubscribeBackgroundTask_001
254 * @tc.desc: test SubscribeBackgroundTask interface.
255 * @tc.type: FUNC
256 * @tc.require: issueI5IRJK
257 */
258 HWTEST_F(BgTaskClientUnitTest, SubscribeBackgroundTask_001, TestSize.Level1)
259 {
260 subscriber_ = std::make_shared<TestBackgroundTaskSubscriber>();
261 EXPECT_NE(subscriber_, nullptr);
262 BackgroundTaskMgrHelper::SubscribeBackgroundTask(*subscriber_);
263 SleepForFC();
264 BackgroundTaskMgrHelper::UnsubscribeBackgroundTask(*subscriber_);
265 SleepForFC();
266 EXPECT_NE(subscriber_, nullptr);
267 }
268
269 /**
270 * @tc.name: GetTransientTaskApps_001
271 * @tc.desc: test GetTransientTaskApps interface.
272 * @tc.type: FUNC
273 * @tc.require: issueI5IRJK
274 */
275 HWTEST_F(BgTaskClientUnitTest, GetTransientTaskApps_001, TestSize.Level1)
276 {
277 std::vector<std::shared_ptr<TransientTaskAppInfo>> list;
278 BackgroundTaskMgrHelper::GetTransientTaskApps(list);
279 EXPECT_TRUE(true);
280 }
281
282 /**
283 * @tc.name: PauseTransientTaskTimeForInner_001
284 * @tc.desc: test PauseTransientTaskTimeForInner interface.
285 * @tc.type: FUNC
286 * @tc.require: issueI936BL
287 */
288 HWTEST_F(BgTaskClientUnitTest, PauseTransientTaskTimeForInner_001, TestSize.Level1)
289 {
290 int32_t uid = -1;
291 EXPECT_NE(BackgroundTaskMgrHelper::PauseTransientTaskTimeForInner(uid), ERR_OK);
292 }
293
294 /**
295 * @tc.name: StartTransientTaskTimeForInner_001
296 * @tc.desc: test StartTransientTaskTimeForInner interface.
297 * @tc.type: FUNC
298 * @tc.require: issueI936BL
299 */
300 HWTEST_F(BgTaskClientUnitTest, StartTransientTaskTimeForInner_001, TestSize.Level1)
301 {
302 int32_t uid = -1;
303 EXPECT_NE(BackgroundTaskMgrHelper::StartTransientTaskTimeForInner(uid), ERR_OK);
304 }
305
306 /**
307 * @tc.name: GetContinuousTaskApps_001
308 * @tc.desc: test GetContinuousTaskApps interface.
309 * @tc.type: FUNC
310 * @tc.require: issueI5IRJK
311 */
312 HWTEST_F(BgTaskClientUnitTest, GetContinuousTaskApps_001, TestSize.Level1)
313 {
314 std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> list;
315 EXPECT_EQ(BackgroundTaskMgrHelper::GetContinuousTaskApps(list), ERR_OK);
316 }
317
318 /**
319 * @tc.name: GetEfficiencyResourcesInfos_001
320 * @tc.desc: test GetEfficiencyResourcesInfos interface.
321 * @tc.type: FUNC
322 * @tc.require: issueI5IRJK
323 */
324 HWTEST_F(BgTaskClientUnitTest, GetEfficiencyResourcesInfos_001, TestSize.Level1)
325 {
326 std::vector<std::shared_ptr<ResourceCallbackInfo>> appList;
327 std::vector<std::shared_ptr<ResourceCallbackInfo>> procList;
328 EXPECT_EQ(BackgroundTaskMgrHelper::GetEfficiencyResourcesInfos(appList, procList), ERR_OK);
329 }
330
331 /**
332 * @tc.name: ApplyEfficiencyResources_001
333 * @tc.desc: test ApplyEfficiencyResources interface.
334 * @tc.type: FUNC
335 * @tc.require: issueI5IRJK
336 */
337 HWTEST_F(BgTaskClientUnitTest, ApplyEfficiencyResources_001, TestSize.Level1)
338 {
339 EfficiencyResourceInfo resourceInfo = EfficiencyResourceInfo();
340 EXPECT_NE(BackgroundTaskMgrHelper::ApplyEfficiencyResources(resourceInfo), ERR_OK);
341 }
342
343 /**
344 * @tc.name: ResetAllEfficiencyResources_001
345 * @tc.desc: test ResetAllEfficiencyResources interface.
346 * @tc.type: FUNC
347 * @tc.require: issueI5IRJK
348 */
349 HWTEST_F(BgTaskClientUnitTest, ResetAllEfficiencyResources_001, TestSize.Level1)
350 {
351 EXPECT_NE((int32_t)BackgroundTaskMgrHelper::ResetAllEfficiencyResources(), (int32_t)ERR_OK);
352 }
353
354 /**
355 * @tc.name: StopContinuousTask_001
356 * @tc.desc: request stop target continuous task api test.
357 * @tc.type: FUNC
358 * @tc.require: issueI5IRJK
359 */
360 HWTEST_F(BgTaskClientUnitTest, StopContinuousTask_001, TestSize.Level1)
361 {
362 EXPECT_EQ((int32_t)BackgroundTaskMgrHelper::StopContinuousTask(1, 1, 1, ""), (int32_t)ERR_OK);
363 }
364
365 /**
366 * @tc.name: BackgroundTaskSubscriber_001
367 * @tc.desc: test BackgroundTaskSubscriber.
368 * @tc.type: FUNC
369 * @tc.require: issueI5IRJK
370 */
371 HWTEST_F(BgTaskClientUnitTest, BackgroundTaskSubscriber_001, TestSize.Level1)
372 {
373 auto subscriber = TestBackgroundTaskSubscriber();
374 auto subscriberImpl = std::make_shared<BackgroundTaskSubscriber::BackgroundTaskSubscriberImpl>(subscriber);
375 subscriberImpl->OnConnected();
376 subscriberImpl->OnDisconnected();
377 subscriberImpl->OnTransientTaskStart(nullptr);
378 EXPECT_EQ(bgtaskSubscriberRet_, "interface3");
379 subscriberImpl->OnTransientTaskEnd(nullptr);
380 EXPECT_EQ(bgtaskSubscriberRet_, "interface4");
381 subscriberImpl->OnTransientTaskErr(nullptr);
382 EXPECT_EQ(bgtaskSubscriberRet_, "interface16");
383 subscriberImpl->OnAppTransientTaskStart(nullptr);
384 EXPECT_EQ(bgtaskSubscriberRet_, "interface5");
385 subscriberImpl->OnAppTransientTaskEnd(nullptr);
386 EXPECT_EQ(bgtaskSubscriberRet_, "interface6");
387 subscriberImpl->OnContinuousTaskStart(nullptr);
388 EXPECT_EQ(bgtaskSubscriberRet_, "interface7");
389 subscriberImpl->OnContinuousTaskStop(nullptr);
390 EXPECT_EQ(bgtaskSubscriberRet_, "interface8");
391 subscriberImpl->OnAppContinuousTaskStop(1);
392 EXPECT_EQ(bgtaskSubscriberRet_, "interface9");
393 subscriberImpl->OnAppEfficiencyResourcesApply(nullptr);
394 EXPECT_EQ(bgtaskSubscriberRet_, "interface11");
395 subscriberImpl->OnAppEfficiencyResourcesReset(nullptr);
396 EXPECT_EQ(bgtaskSubscriberRet_, "interface12");
397 subscriberImpl->OnProcEfficiencyResourcesApply(nullptr);
398 EXPECT_EQ(bgtaskSubscriberRet_, "interface13");
399 subscriberImpl->OnProcEfficiencyResourcesReset(nullptr);
400 EXPECT_EQ(bgtaskSubscriberRet_, "interface14");
401 subscriberImpl->OnContinuousTaskUpdate(nullptr);
402 EXPECT_EQ(bgtaskSubscriberRet_, "interface15");
403 }
404
405 /**
406 * @tc.name: BackgroundTaskSubscriber_002
407 * @tc.desc: test BackgroundTaskSubscriber.
408 * @tc.type: FUNC
409 * @tc.require: issueI5IRJK
410 */
411 HWTEST_F(BgTaskClientUnitTest, BackgroundTaskSubscriber_002, TestSize.Level1)
412 {
413 auto subscriber = BackgroundTaskSubscriber();
414 subscriber.OnConnected();
415 subscriber.OnDisconnected();
416 subscriber.OnTransientTaskStart(nullptr);
417 subscriber.OnTransientTaskEnd(nullptr);
418 subscriber.OnTransientTaskErr(nullptr);
419 subscriber.OnAppTransientTaskStart(nullptr);
420 subscriber.OnAppTransientTaskEnd(nullptr);
421 subscriber.OnContinuousTaskStart(nullptr);
422 subscriber.OnContinuousTaskUpdate(nullptr);
423 subscriber.OnContinuousTaskStop(nullptr);
424 subscriber.OnAppContinuousTaskStop(1);
425 subscriber.OnRemoteDied(nullptr);
426 subscriber.OnAppEfficiencyResourcesApply(nullptr);
427 subscriber.OnAppEfficiencyResourcesReset(nullptr);
428 subscriber.OnProcEfficiencyResourcesApply(nullptr);
429 subscriber.OnProcEfficiencyResourcesReset(nullptr);
430 EXPECT_NE(subscriber.GetImpl(), nullptr);
431 }
432
433 /**
434 * @tc.name: ContinuousTaskCallbackInfo_001
435 * @tc.desc: test ContinuousTaskCallbackInfo.
436 * @tc.type: FUNC
437 * @tc.require: issueI5IRJK
438 */
439 HWTEST_F(BgTaskClientUnitTest, ContinuousTaskCallbackInfo_001, TestSize.Level1)
440 {
441 sptr<ContinuousTaskCallbackInfo> info1 = sptr<ContinuousTaskCallbackInfo>(new ContinuousTaskCallbackInfo());
442 sptr<ContinuousTaskCallbackInfo> info2 = sptr<ContinuousTaskCallbackInfo>(
443 new ContinuousTaskCallbackInfo(1, 1, 1, "test"));
444
445 Parcel parcel = Parcel();
446 info2->Marshalling(parcel);
447 sptr<ContinuousTaskCallbackInfo> info3 = sptr<ContinuousTaskCallbackInfo>(
448 ContinuousTaskCallbackInfo::Unmarshalling(parcel));
449 EXPECT_EQ(info3->GetTypeId(), 1);
450 EXPECT_EQ(info3->GetCreatorUid(), 1);
451 EXPECT_EQ(info3->GetCreatorPid(), 1);
452 EXPECT_EQ(info3->GetAbilityName(), "test");
453 EXPECT_EQ(info3->IsFromWebview(), false);
454 EXPECT_EQ(info3->GetTokenId(), 0);
455 }
456
457 /**
458 * @tc.name: ContinuousTaskParam_001
459 * @tc.desc: test ContinuousTaskParam.
460 * @tc.type: FUNC
461 * @tc.require: issueI5IRJK
462 */
463 HWTEST_F(BgTaskClientUnitTest, ContinuousTaskParam_001, TestSize.Level1)
464 {
465 sptr<ContinuousTaskParam> info1 = sptr<ContinuousTaskParam>(new ContinuousTaskParam());
466 sptr<ContinuousTaskParam> info2 = sptr<ContinuousTaskParam>(
467 new ContinuousTaskParam(true, 1, nullptr, "abilityName", nullptr, "appName"));
468
469 Parcel parcel1 = Parcel();
470 info2->Marshalling(parcel1);
471 sptr<ContinuousTaskParam> info3 = sptr<ContinuousTaskParam>(new ContinuousTaskParam());
472 info3->ReadFromParcel(parcel1);
473 Parcel parcel2 = Parcel();
474 info3->Marshalling(parcel2);
475 sptr<ContinuousTaskParam> info4 = sptr<ContinuousTaskParam>(
476 ContinuousTaskParam::Unmarshalling(parcel2));
477 EXPECT_EQ(info4->isNewApi_, true);
478 EXPECT_EQ(info4->bgModeId_, 1);
479 EXPECT_EQ(info4->wantAgent_, nullptr);
480 EXPECT_EQ(info4->abilityName_, "abilityName");
481 EXPECT_EQ(info4->abilityToken_, nullptr);
482 EXPECT_EQ(info4->appName_, "appName");
483 }
484
485 /**
486 * @tc.name: ContinuousTaskParamForInner_001
487 * @tc.desc: test ContinuousTaskParamForInner.
488 * @tc.type: FUNC
489 * @tc.require: issueI5IRJK
490 */
491 HWTEST_F(BgTaskClientUnitTest, ContinuousTaskParamForInner_001, TestSize.Level1)
492 {
493 sptr<ContinuousTaskParamForInner> info1 = sptr<ContinuousTaskParamForInner>(new ContinuousTaskParamForInner());
494 sptr<ContinuousTaskParamForInner> info2 = sptr<ContinuousTaskParamForInner>(
495 new ContinuousTaskParamForInner(1, 1, true));
496
497 Parcel parcel1 = Parcel();
498 info2->Marshalling(parcel1);
499 sptr<ContinuousTaskParamForInner> info3 = sptr<ContinuousTaskParamForInner>(new ContinuousTaskParamForInner());
500 info3->ReadFromParcel(parcel1);
501 Parcel parcel2 = Parcel();
502 info3->Marshalling(parcel2);
503 sptr<ContinuousTaskParamForInner> info4 = sptr<ContinuousTaskParamForInner>(
504 ContinuousTaskParamForInner::Unmarshalling(parcel2));
505 EXPECT_EQ(info4->uid_, 1);
506 EXPECT_EQ(info4->bgModeId_, 1);
507 EXPECT_EQ(info4->isStart_, true);
508 }
509
510 /**
511 * @tc.name: DelaySuspendInfo_001
512 * @tc.desc: test DelaySuspendInfo.
513 * @tc.type: FUNC
514 * @tc.require: issueI5IRJK
515 */
516 HWTEST_F(BgTaskClientUnitTest, DelaySuspendInfo_001, TestSize.Level1)
517 {
518 sptr<DelaySuspendInfo> info1 = sptr<DelaySuspendInfo>(new DelaySuspendInfo());
519 info1->SetRequestId(1);
520 info1->SetActualDelayTime(1);
521
522 Parcel parcel = Parcel();
523 info1->Marshalling(parcel);
524
525 auto info2 = DelaySuspendInfo::Unmarshalling(parcel);
526 EXPECT_EQ(info2->GetRequestId(), 1);
527 EXPECT_EQ(info2->GetActualDelayTime(), 1);
528 EXPECT_EQ(info2->IsSameRequestId(1), true);
529 }
530
531 /**
532 * @tc.name: EfficiencyResourceInfo_001
533 * @tc.desc: test EfficiencyResourceInfo.
534 * @tc.type: FUNC
535 * @tc.require: issueI5IRJK
536 */
537 HWTEST_F(BgTaskClientUnitTest, EfficiencyResourceInfo_001, TestSize.Level1)
538 {
539 sptr<EfficiencyResourceInfo> info1 = sptr<EfficiencyResourceInfo>(new EfficiencyResourceInfo());
540 sptr<EfficiencyResourceInfo> info2 = sptr<EfficiencyResourceInfo>(
541 new EfficiencyResourceInfo(0, true, 1, "test", true, false));
542 info2->SetResourceNumber(1);
543 info2->SetProcess(true);
544
545 Parcel parcel = Parcel();
546 info2->Marshalling(parcel);
547 sptr<EfficiencyResourceInfo> info3 = EfficiencyResourceInfo::Unmarshalling(parcel);
548 EXPECT_EQ(info2->GetResourceNumber(), 1);
549 EXPECT_EQ(info2->IsApply(), true);
550 EXPECT_EQ(info2->GetTimeOut(), 1);
551 EXPECT_EQ(info2->GetReason(), "test");
552 EXPECT_EQ(info2->IsPersist(), true);
553 EXPECT_EQ(info2->IsProcess(), true);
554 }
555
556 /**
557 * @tc.name: ExpiredCallback_001
558 * @tc.desc: test ExpiredCallback.
559 * @tc.type: FUNC
560 * @tc.require: issueI5IRJK
561 */
562 HWTEST_F(BgTaskClientUnitTest, ExpiredCallback_001, TestSize.Level1)
563 {
564 auto expiredCallback = std::make_shared<TestExpiredCallback>();
565 expiredCallback->Init();
566 auto expiredCallbackImpl = std::make_shared<ExpiredCallback::ExpiredCallbackImpl>(expiredCallback);
567 expiredCallbackImpl->OnExpired();
568 EXPECT_EQ(expiredCallbackRet_, "OnExpired");
569 }
570
571 /**
572 * @tc.name: ResourceCallbackInfo_001
573 * @tc.desc: test ResourceCallbackInfo.
574 * @tc.type: FUNC
575 * @tc.require: issueI5IRJK
576 */
577 HWTEST_F(BgTaskClientUnitTest, ResourceCallbackInfo_001, TestSize.Level1)
578 {
579 sptr<ResourceCallbackInfo> info1 = sptr<ResourceCallbackInfo>(new ResourceCallbackInfo());
580 sptr<ResourceCallbackInfo> info2 = sptr<ResourceCallbackInfo>(
581 new ResourceCallbackInfo(1, 1, 1, "bundleName"));
582 EXPECT_EQ(info2->GetResourceNumber(), 1);
583
584 info2->SetResourceNumber(2);
585 Parcel parcel = Parcel();
586 info2->Marshalling(parcel);
587 sptr<ResourceCallbackInfo> info3 = ResourceCallbackInfo::Unmarshalling(parcel);
588 EXPECT_EQ(info3->GetUid(), 1);
589 EXPECT_EQ(info3->GetPid(), 1);
590 EXPECT_EQ(info3->GetResourceNumber(), 2);
591 EXPECT_EQ(info3->GetBundleName(), "bundleName");
592 }
593
594 /**
595 * @tc.name: ResourceType_001
596 * @tc.desc: test ResourceType.
597 * @tc.type: FUNC
598 * @tc.require: issueI5IRJK
599 */
600 HWTEST_F(BgTaskClientUnitTest, ResourceType_001, TestSize.Level1)
601 {
602 EXPECT_EQ(CPU_TYPE, (uint32_t)ResourceType::CPU);
603 EXPECT_EQ(COMMON_EVENT_TYPE, (uint32_t)ResourceType::COMMON_EVENT);
604 EXPECT_EQ(TIMER_TYPE, (uint32_t)ResourceType::TIMER);
605 EXPECT_EQ(WORK_SCHEDULER_TYPE, (uint32_t)ResourceType::WORK_SCHEDULER);
606 EXPECT_EQ(BLUETOOTH_TYPE, (uint32_t)ResourceType::BLUETOOTH);
607 EXPECT_EQ(GPS_TYPE, (uint32_t)ResourceType::GPS);
608 EXPECT_EQ(AUDIO_TYPE, (uint32_t)ResourceType::AUDIO);
609 EXPECT_EQ(RUNNING_LOCK, (uint32_t)ResourceType::RUNNING_LOCK);
610 EXPECT_EQ(SENSOR, (uint32_t)ResourceType::SENSOR);
611 }
612
613 /**
614 * @tc.name: TransientTaskAppInfo_001
615 * @tc.desc: test TransientTaskAppInfo.
616 * @tc.type: FUNC
617 * @tc.require: issueI5IRJK
618 */
619 HWTEST_F(BgTaskClientUnitTest, TransientTaskAppInfo_001, TestSize.Level1)
620 {
621 std::shared_ptr<TransientTaskAppInfo> info1 = std::make_shared<TransientTaskAppInfo>();
622 std::shared_ptr<TransientTaskAppInfo> info2 = std::make_shared<TransientTaskAppInfo>(
623 "packageName", 1, 1);
624
625 MessageParcel parcel = MessageParcel();
626 info2->Marshalling(parcel);
627 std::shared_ptr<TransientTaskAppInfo> info3 = TransientTaskAppInfo::Unmarshalling(parcel);
628 EXPECT_EQ(info3->GetPackageName(), "packageName");
629 EXPECT_EQ(info3->GetUid(), 1);
630 EXPECT_EQ(info3->GetPid(), 1);
631 }
632
633 /**
634 * @tc.name: SetBgTaskConfig_001
635 * @tc.desc: test SetBgTaskConfig interface.
636 * @tc.type: FUNC
637 * @tc.require: issueIAULHW
638 */
639 HWTEST_F(BgTaskClientUnitTest, SetBgTaskConfig_001, TestSize.Level1)
640 {
641 const std::string configData = "";
642 EXPECT_NE(BackgroundTaskMgrHelper::SetBgTaskConfig(configData, 1), ERR_OK);
643 }
644 }
645 }