1 /* 2 * Copyright (c) 2022-2025 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 #include <functional> 16 #include <chrono> 17 #include <thread> 18 #include <message_parcel.h> 19 20 #include "gtest/gtest.h" 21 22 #include "background_task_manager.h" 23 #include "background_task_subscriber.h" 24 #include "background_task_subscriber_stub.h" 25 #include "background_task_subscriber_proxy.h" 26 #include "bgtaskmgr_inner_errors.h" 27 #include "bgtaskmgr_log_wrapper.h" 28 #include "continuous_task_callback_info.h" 29 #include "continuous_task_info.h" 30 #include "continuous_task_param.h" 31 #include "delay_suspend_info.h" 32 #include "efficiency_resource_info.h" 33 #include "expired_callback.h" 34 #include "expired_callback_proxy.h" 35 #include "expired_callback_stub.h" 36 #include "iservice_registry.h" 37 #include "resource_callback_info.h" 38 #include "singleton.h" 39 #include "transient_task_app_info.h" 40 41 using namespace testing::ext; 42 43 namespace OHOS { 44 namespace BackgroundTaskMgr { 45 namespace { 46 constexpr int32_t SLEEP_TIME = 500; 47 constexpr uint32_t ON_CONNECTED = 1; 48 constexpr uint32_t ON_DISCONNECTED = 2; 49 constexpr uint32_t ON_TRANSIENT_TASK_START = 3; 50 constexpr uint32_t ON_TRANSIENT_TASK_END = 4; 51 constexpr uint32_t ON_TRANSIENT_TASK_ERR = 15; 52 constexpr uint32_t ON_APP_TRANSIENT_TASK_START = 5; 53 constexpr uint32_t ON_APP_TRANSIENT_TASK_END = 6; 54 constexpr uint32_t ON_CONTINUOUS_TASK_START = 7; 55 constexpr uint32_t ON_CONTINUOUS_TASK_STOP = 8; 56 constexpr uint32_t ON_APP_CONTINUOUS_TASK_STOP = 9; 57 } 58 class BgTaskFrameworkUnitTest : public testing::Test { 59 public: SetUpTestCase()60 static void SetUpTestCase() {} TearDownTestCase()61 static void TearDownTestCase() {} SetUp()62 void SetUp() override {} TearDown()63 void TearDown() override {} SleepForFC()64 inline void SleepForFC() 65 { 66 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME)); 67 } 68 }; 69 70 class TestExpiredCallback : public ExpiredCallback { 71 public: OnExpired()72 void OnExpired() override {} 73 }; 74 75 class TestBackgroundTaskSubscriber : public BackgroundTaskSubscriber {}; 76 77 class TestBackgroundTaskSubscriberStub : public BackgroundTaskSubscriberStub { OnConnected()78 ErrCode OnConnected() override {return ERR_OK;} OnDisconnected()79 ErrCode OnDisconnected() override {return ERR_OK;} OnTransientTaskStart(const TransientTaskAppInfo & info)80 ErrCode OnTransientTaskStart(const TransientTaskAppInfo& info) override {return ERR_OK;} OnAppTransientTaskStart(const TransientTaskAppInfo & info)81 ErrCode OnAppTransientTaskStart(const TransientTaskAppInfo& info) override {return ERR_OK;} OnAppTransientTaskEnd(const TransientTaskAppInfo & info)82 ErrCode OnAppTransientTaskEnd(const TransientTaskAppInfo& info) override {return ERR_OK;} OnTransientTaskEnd(const TransientTaskAppInfo & info)83 ErrCode OnTransientTaskEnd(const TransientTaskAppInfo& info) override {return ERR_OK;} OnTransientTaskErr(const TransientTaskAppInfo & info)84 ErrCode OnTransientTaskErr(const TransientTaskAppInfo& info) override {return ERR_OK;} OnContinuousTaskStart(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)85 ErrCode OnContinuousTaskStart( 86 const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;} OnContinuousTaskUpdate(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)87 ErrCode OnContinuousTaskUpdate( 88 const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;} OnContinuousTaskStop(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)89 ErrCode OnContinuousTaskStop( 90 const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;} OnContinuousTaskSuspend(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)91 ErrCode OnContinuousTaskSuspend( 92 const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;} OnContinuousTaskActive(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)93 ErrCode OnContinuousTaskActive( 94 const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;} OnAppContinuousTaskStop(int32_t uid)95 ErrCode OnAppContinuousTaskStop(int32_t uid) override {return ERR_OK;} OnAppEfficiencyResourcesApply(const ResourceCallbackInfo & resourceInfo)96 ErrCode OnAppEfficiencyResourcesApply(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;} OnAppEfficiencyResourcesReset(const ResourceCallbackInfo & resourceInfo)97 ErrCode OnAppEfficiencyResourcesReset(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;} OnProcEfficiencyResourcesApply(const ResourceCallbackInfo & resourceInfo)98 ErrCode OnProcEfficiencyResourcesApply(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;} OnProcEfficiencyResourcesReset(const ResourceCallbackInfo & resourceInfo)99 ErrCode OnProcEfficiencyResourcesReset(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;} GetFlag(int32_t & flag)100 ErrCode GetFlag(int32_t &flag) override {return ERR_OK;} 101 }; 102 103 class TestExpiredCallbackStub : public ExpiredCallbackStub { 104 public: OnExpired()105 ErrCode OnExpired() override {return ERR_OK;} 106 }; 107 108 /** 109 * @tc.name: BgTaskFrameworkUnitTest_001 110 * @tc.desc: test RequestSuspendDelay. 111 * @tc.type: FUNC 112 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 113 */ 114 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_001, TestSize.Level1) 115 { 116 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 117 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 118 std::shared_ptr<DelaySuspendInfo> delayInfo = std::make_shared<DelaySuspendInfo>(); 119 auto expiredCallback = std::make_shared<TestExpiredCallback>(); 120 121 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestSuspendDelay( 122 u"test", *expiredCallback, delayInfo), ERR_BGTASK_SERVICE_NOT_CONNECTED); 123 SystemAbilityManagerClient::GetInstance().action_ = ""; 124 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestSuspendDelay( 125 u"test", *expiredCallback, delayInfo), ERR_OK); 126 expiredCallback->Init(); 127 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestSuspendDelay( 128 u"test", *expiredCallback, delayInfo), ERR_OK); 129 } 130 131 /** 132 * @tc.name: BgTaskFrameworkUnitTest_002 133 * @tc.desc: test GetRemainingDelayTime. 134 * @tc.type: FUNC 135 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 136 */ 137 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_002, TestSize.Level1) 138 { 139 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 140 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 141 int32_t delayTime = -1; 142 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetRemainingDelayTime(-1, delayTime), 143 ERR_BGTASK_SERVICE_NOT_CONNECTED); 144 SystemAbilityManagerClient::GetInstance().action_ = ""; 145 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetRemainingDelayTime(-1, delayTime), ERR_OK); 146 } 147 148 /** 149 * @tc.name: BgTaskFrameworkUnitTest_003 150 * @tc.desc: test CancelSuspendDelay. 151 * @tc.type: FUNC 152 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 153 */ 154 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_003, TestSize.Level1) 155 { 156 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 157 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 158 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->CancelSuspendDelay(-1), 159 ERR_BGTASK_SERVICE_NOT_CONNECTED); 160 SystemAbilityManagerClient::GetInstance().action_ = ""; 161 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->CancelSuspendDelay(-1), ERR_OK); 162 } 163 164 /** 165 * @tc.name: BgTaskFrameworkUnitTest_004 166 * @tc.desc: test RequestStartBackgroundRunning. 167 * @tc.type: FUNC 168 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 169 */ 170 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_004, TestSize.Level1) 171 { 172 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 173 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 174 ContinuousTaskParam taskParam = ContinuousTaskParam(); 175 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStartBackgroundRunning(taskParam), 176 ERR_BGTASK_SERVICE_NOT_CONNECTED); 177 SystemAbilityManagerClient::GetInstance().action_ = ""; 178 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStartBackgroundRunning(taskParam), 179 ERR_OK); 180 } 181 182 /** 183 * @tc.name: BgTaskFrameworkUnitTest_005 184 * @tc.desc: test RequestStopBackgroundRunning. 185 * @tc.type: FUNC 186 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V issueI99HSB 187 */ 188 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_005, TestSize.Level1) 189 { 190 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 191 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 192 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStopBackgroundRunning("test", nullptr, -1), 193 ERR_BGTASK_SERVICE_NOT_CONNECTED); 194 SystemAbilityManagerClient::GetInstance().action_ = ""; 195 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStopBackgroundRunning("test", nullptr, -1), 196 ERR_OK); 197 } 198 199 /** 200 * @tc.name: BgTaskFrameworkUnitTest_006 201 * @tc.desc: test SubscribeBackgroundTask. 202 * @tc.type: FUNC 203 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 204 */ 205 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_006, TestSize.Level1) 206 { 207 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 208 TestBackgroundTaskSubscriber taskSubscriber = TestBackgroundTaskSubscriber(); 209 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 210 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->SubscribeBackgroundTask(taskSubscriber), 211 ERR_BGTASK_SERVICE_NOT_CONNECTED); 212 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->UnsubscribeBackgroundTask(taskSubscriber), 213 ERR_BGTASK_SERVICE_NOT_CONNECTED); 214 SystemAbilityManagerClient::GetInstance().action_ = ""; 215 } 216 217 /** 218 * @tc.name: BgTaskFrameworkUnitTest_007 219 * @tc.desc: test GetTransientTaskApps. 220 * @tc.type: FUNC 221 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 222 */ 223 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_007, TestSize.Level1) 224 { 225 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 226 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 227 std::vector<std::shared_ptr<TransientTaskAppInfo>> list; 228 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetTransientTaskApps(list), 229 ERR_BGTASK_SERVICE_NOT_CONNECTED); 230 SystemAbilityManagerClient::GetInstance().action_ = ""; 231 DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetTransientTaskApps(list); 232 EXPECT_TRUE(true); 233 } 234 235 /** 236 * @tc.name: BgTaskFrameworkUnitTest_008 237 * @tc.desc: test GetContinuousTaskApps. 238 * @tc.type: FUNC 239 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 240 */ 241 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_008, TestSize.Level1) 242 { 243 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 244 245 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 246 std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> list; 247 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetContinuousTaskApps(list), 248 ERR_BGTASK_SERVICE_NOT_CONNECTED); 249 SystemAbilityManagerClient::GetInstance().action_ = ""; 250 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetContinuousTaskApps(list), ERR_OK); 251 } 252 253 /** 254 * @tc.name: BgTaskFrameworkUnitTest_009 255 * @tc.desc: test ApplyEfficiencyResources. 256 * @tc.type: FUNC 257 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 258 */ 259 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_009, TestSize.Level1) 260 { 261 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 262 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 263 EfficiencyResourceInfo resourceInfo = EfficiencyResourceInfo(); 264 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->ApplyEfficiencyResources( 265 resourceInfo), ERR_BGTASK_SERVICE_NOT_CONNECTED); 266 SystemAbilityManagerClient::GetInstance().action_ = ""; 267 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->ApplyEfficiencyResources( 268 resourceInfo), ERR_OK); 269 } 270 271 /** 272 * @tc.name: BgTaskFrameworkUnitTest_010 273 * @tc.desc: test ResetAllEfficiencyResources. 274 * @tc.type: FUNC 275 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 276 */ 277 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_0010, TestSize.Level1) 278 { 279 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 280 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 281 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->ResetAllEfficiencyResources(), 282 ERR_BGTASK_SERVICE_NOT_CONNECTED); 283 SystemAbilityManagerClient::GetInstance().action_ = ""; 284 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->ResetAllEfficiencyResources(), ERR_OK); 285 } 286 287 /** 288 * @tc.name: BgTaskFrameworkUnitTest_011 289 * @tc.desc: test GetEfficiencyResourcesInfos. 290 * @tc.type: FUNC 291 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 292 */ 293 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_011, TestSize.Level1) 294 { 295 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 296 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 297 std::vector<std::shared_ptr<ResourceCallbackInfo>> appList; 298 std::vector<std::shared_ptr<ResourceCallbackInfo>> procList; 299 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetEfficiencyResourcesInfos(appList, procList), 300 ERR_BGTASK_SERVICE_NOT_CONNECTED); 301 SystemAbilityManagerClient::GetInstance().action_ = ""; 302 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetEfficiencyResourcesInfos(appList, procList), 303 ERR_OK); 304 } 305 306 /** 307 * @tc.name: BgTaskFrameworkUnitTest_012 308 * @tc.desc: test StopContinuousTask. 309 * @tc.type: FUNC 310 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 311 */ 312 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_012, TestSize.Level1) 313 { 314 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 315 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 316 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->StopContinuousTask(1, 1, 1, ""), 317 ERR_BGTASK_SERVICE_NOT_CONNECTED); 318 319 SystemAbilityManagerClient::GetInstance().action_ = ""; 320 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->StopContinuousTask(1, 1, 1, ""), 321 ERR_BGTASK_PERMISSION_DENIED); 322 } 323 324 /** 325 * @tc.name: BgTaskFrameworkUnitTest_013 326 * @tc.desc: test GetBackgroundTaskManagerProxy. 327 * @tc.type: FUNC 328 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 329 */ 330 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_013, TestSize.Level1) 331 { 332 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 333 SystemAbilityManagerClient::GetInstance().action_ = ""; 334 DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetBackgroundTaskManagerProxy(); 335 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_, nullptr); 336 DelayedSingleton<BackgroundTaskManager>::GetInstance()->ResetBackgroundTaskManagerProxy(); 337 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_, nullptr); 338 } 339 340 /** 341 * @tc.name: BgTaskFrameworkUnitTest_014 342 * @tc.desc: test RequestBackgroundRunningForInner. 343 * @tc.type: FUNC 344 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 345 */ 346 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_014, TestSize.Level1) 347 { 348 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 349 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 350 ContinuousTaskParamForInner taskParam = ContinuousTaskParamForInner(); 351 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestBackgroundRunningForInner(taskParam), 352 ERR_BGTASK_SERVICE_NOT_CONNECTED); 353 SystemAbilityManagerClient::GetInstance().action_ = ""; 354 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestBackgroundRunningForInner(taskParam), 355 ERR_OK); 356 } 357 358 /** 359 * @tc.name: BgTaskFrameworkUnitTest_015 360 * @tc.desc: test PauseTransientTaskTimeForInner. 361 * @tc.type: FUNC 362 * @tc.require: issueI936BL 363 */ 364 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_015, TestSize.Level1) 365 { 366 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 367 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 368 int32_t uid = -1; 369 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->PauseTransientTaskTimeForInner(uid), 370 ERR_BGTASK_SERVICE_NOT_CONNECTED); 371 SystemAbilityManagerClient::GetInstance().action_ = ""; 372 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->PauseTransientTaskTimeForInner(uid), 373 ERR_OK); 374 } 375 376 /** 377 * @tc.name: BgTaskFrameworkUnitTest_016 378 * @tc.desc: test StartTransientTaskTimeForInner. 379 * @tc.type: FUNC 380 * @tc.require: issueI936BL 381 */ 382 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_016, TestSize.Level1) 383 { 384 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 385 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 386 int32_t uid = -1; 387 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->StartTransientTaskTimeForInner(uid), 388 ERR_BGTASK_SERVICE_NOT_CONNECTED); 389 SystemAbilityManagerClient::GetInstance().action_ = ""; 390 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->StartTransientTaskTimeForInner(uid), 391 ERR_OK); 392 } 393 394 /** 395 * @tc.name: BgTaskFrameworkUnitTest_017 396 * @tc.desc: test GetAllEfficiencyResources. 397 * @tc.type: FUNC 398 * @tc.require: issuesIC3JY3 399 */ 400 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_017, TestSize.Level1) 401 { 402 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 403 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 404 std::vector<std::shared_ptr<EfficiencyResourceInfo>> resourceInfoList; 405 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetAllEfficiencyResources(resourceInfoList), 406 ERR_BGTASK_RESOURCES_SERVICE_NOT_CONNECTED); 407 SystemAbilityManagerClient::GetInstance().action_ = ""; 408 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetAllEfficiencyResources(resourceInfoList), 409 ERR_OK); 410 } 411 412 /** 413 * @tc.name: BgTaskFrameworkUnitTest_018 414 * @tc.desc: test SuspendContinuousTask. 415 * @tc.type: FUNC 416 * @tc.require: issueIC6B53 417 */ 418 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_018, TestSize.Level1) 419 { 420 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 421 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 422 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->SuspendContinuousTask(1, 1, 4, ""), 423 ERR_BGTASK_SERVICE_NOT_CONNECTED); 424 425 SystemAbilityManagerClient::GetInstance().action_ = ""; 426 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->SuspendContinuousTask(1, 1, 4, ""), 427 ERR_BGTASK_PERMISSION_DENIED); 428 } 429 430 /** 431 * @tc.name: BgTaskFrameworkUnitTest_019 432 * @tc.desc: test ActiveContinuousTask. 433 * @tc.type: FUNC 434 * @tc.require: issueIC6B53 435 */ 436 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_019, TestSize.Level1) 437 { 438 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 439 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 440 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->ActiveContinuousTask(1, 1, ""), 441 ERR_BGTASK_SERVICE_NOT_CONNECTED); 442 443 SystemAbilityManagerClient::GetInstance().action_ = ""; 444 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->ActiveContinuousTask(1, 1, ""), 445 ERR_BGTASK_PERMISSION_DENIED); 446 } 447 448 /** 449 * @tc.name: BackgroundTaskSubscriberProxyTest_001 450 * @tc.desc: test BackgroundTaskSubscriberProxy. 451 * @tc.type: FUNC 452 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 453 */ 454 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_001, TestSize.Level1) 455 { 456 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 457 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 458 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 459 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 460 subscirberProxy1.OnConnected(); 461 subscirberProxy2.OnConnected(); 462 subscirberProxy1.OnDisconnected(); 463 subscirberProxy2.OnDisconnected(); 464 EXPECT_NE(subscirberStub, nullptr); 465 } 466 467 /** 468 * @tc.name: BackgroundTaskSubscriberProxyTest_002 469 * @tc.desc: test BackgroundTaskSubscriberProxy. 470 * @tc.type: FUNC 471 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 472 */ 473 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_002, TestSize.Level1) 474 { 475 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 476 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 477 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 478 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 479 std::shared_ptr<TransientTaskAppInfo> info = std::make_shared<TransientTaskAppInfo>(); 480 subscirberProxy2.OnTransientTaskStart(*info); 481 subscirberProxy2.OnTransientTaskEnd(*info); 482 subscirberProxy2.OnTransientTaskErr(*info); 483 subscirberProxy2.OnAppTransientTaskStart(*info); 484 subscirberProxy2.OnAppTransientTaskEnd(*info); 485 EXPECT_NE(subscirberStub, nullptr); 486 } 487 488 /** 489 * @tc.name: BackgroundTaskSubscriberProxyTest_003 490 * @tc.desc: test BackgroundTaskSubscriberProxy. 491 * @tc.type: FUNC 492 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 493 */ 494 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_003, TestSize.Level1) 495 { 496 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 497 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 498 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 499 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 500 subscirberProxy1.OnAppContinuousTaskStop(-1); 501 subscirberProxy2.OnAppContinuousTaskStop(-1); 502 std::shared_ptr<ContinuousTaskCallbackInfo> info = std::make_shared<ContinuousTaskCallbackInfo>(); 503 subscirberProxy2.OnContinuousTaskStart(*info); 504 subscirberProxy2.OnContinuousTaskStop(*info); 505 EXPECT_NE(subscirberStub, nullptr); 506 } 507 508 /** 509 * @tc.name: BackgroundTaskSubscriberProxyTest_004 510 * @tc.desc: test BackgroundTaskSubscriberProxy. 511 * @tc.type: FUNC 512 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 513 */ 514 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_004, TestSize.Level1) 515 { 516 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 517 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 518 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 519 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 520 std::shared_ptr<ResourceCallbackInfo> info = std::make_shared<ResourceCallbackInfo>(); 521 subscirberProxy2.OnAppEfficiencyResourcesApply(*info); 522 subscirberProxy2.OnAppEfficiencyResourcesReset(*info); 523 subscirberProxy2.OnProcEfficiencyResourcesApply(*info); 524 subscirberProxy2.OnProcEfficiencyResourcesReset(*info); 525 EXPECT_NE(subscirberStub, nullptr); 526 } 527 528 /** 529 * @tc.name: BackgroundTaskSubscriberProxyTest_005 530 * @tc.desc: test BackgroundTaskSubscriberProxy. 531 * @tc.type: FUNC 532 * @tc.require: issueIC6B53 533 */ 534 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_005, TestSize.Level1) 535 { 536 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 537 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 538 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 539 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 540 std::shared_ptr<ContinuousTaskCallbackInfo> info = std::make_shared<ContinuousTaskCallbackInfo>(); 541 subscirberProxy2.OnContinuousTaskSuspend(*info); 542 subscirberProxy2.OnContinuousTaskActive(*info); 543 EXPECT_NE(subscirberStub, nullptr); 544 } 545 546 /** 547 * @tc.name: BackgroundTaskSubscriberProxyTest_006 548 * @tc.desc: test BackgroundTaskSubscriberProxy. 549 * @tc.type: FUNC 550 * @tc.require: issueIC6B53 551 */ 552 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_006, TestSize.Level1) 553 { 554 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 555 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 556 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 557 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 558 int32_t flag = 1; 559 subscirberProxy1.GetFlag(flag); 560 flag = 2; 561 subscirberProxy2.GetFlag(flag); 562 EXPECT_NE(subscirberStub, nullptr); 563 } 564 565 /** 566 * @tc.name: BackgroundTaskSubscriberStubTest_001 567 * @tc.desc: test BackgroundTaskSubscriberStub. 568 * @tc.type: FUNC 569 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 570 */ 571 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_001, TestSize.Level1) 572 { 573 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 574 MessageParcel data1; 575 MessageParcel data2; 576 MessageParcel reply; 577 MessageOption option; 578 std::u16string descriptor = u"test"; 579 data1.WriteInterfaceToken(descriptor); 580 EXPECT_NE(subscirberStub.OnRemoteRequest(1, data1, reply, option), ERR_OK); 581 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 582 EXPECT_NE(subscirberStub.OnRemoteRequest(100, data2, reply, option), ERR_OK); 583 } 584 585 /** 586 * @tc.name: BackgroundTaskSubscriberStubTest_002 587 * @tc.desc: test BackgroundTaskSubscriberStub. 588 * @tc.type: FUNC 589 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 590 */ 591 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_002, TestSize.Level1) 592 { 593 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 594 MessageParcel reply; 595 MessageOption option; 596 MessageParcel data1; 597 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 598 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONNECTED, data1, reply, option), ERR_OK); 599 MessageParcel data2; 600 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 601 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_DISCONNECTED, data1, reply, option), ERR_OK); 602 } 603 604 /** 605 * @tc.name: BackgroundTaskSubscriberStubTest_003 606 * @tc.desc: test BackgroundTaskSubscriberStub. 607 * @tc.type: FUNC 608 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 609 */ 610 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_003, TestSize.Level1) 611 { 612 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 613 MessageParcel reply; 614 MessageOption option; 615 std::shared_ptr<TransientTaskAppInfo> info = std::make_shared<TransientTaskAppInfo>(); 616 MessageParcel data1; 617 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 618 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_START, data1, reply, option), ERR_OK); 619 MessageParcel data2; 620 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 621 data2.WriteParcelable(info.get()); 622 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_START, data2, reply, option), ERR_OK); 623 624 MessageParcel data3; 625 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 626 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_END, data3, reply, option), ERR_OK); 627 MessageParcel data4; 628 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 629 data4.WriteParcelable(info.get()); 630 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_END, data4, reply, option), ERR_OK); 631 632 MessageParcel data9; 633 data9.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 634 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_ERR, data9, reply, option), ERR_OK); 635 MessageParcel data10; 636 data10.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 637 data10.WriteParcelable(info.get()); 638 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_ERR, data10, reply, option), ERR_OK); 639 640 MessageParcel data5; 641 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 642 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_START, data5, reply, option), ERR_OK); 643 MessageParcel data6; 644 data6.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 645 data6.WriteParcelable(info.get()); 646 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_START, data6, reply, option), ERR_OK); 647 648 MessageParcel data7; 649 data7.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 650 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_END, data7, reply, option), ERR_OK); 651 MessageParcel data8; 652 data8.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 653 data8.WriteParcelable(info.get()); 654 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_END, data8, reply, option), ERR_OK); 655 } 656 657 /** 658 * @tc.name: BackgroundTaskSubscriberStubTest_004 659 * @tc.desc: test BackgroundTaskSubscriberStub. 660 * @tc.type: FUNC 661 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 662 */ 663 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_004, TestSize.Level1) 664 { 665 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 666 MessageParcel reply; 667 MessageOption option; 668 std::shared_ptr<ContinuousTaskCallbackInfo> info = std::make_shared<ContinuousTaskCallbackInfo>(); 669 MessageParcel data1; 670 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 671 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_START, data1, reply, option), ERR_OK); 672 MessageParcel data2; 673 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 674 data2.WriteParcelable(info.get()); 675 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_START, data2, reply, option), ERR_OK); 676 677 MessageParcel data3; 678 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 679 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_STOP, data3, reply, option), ERR_OK); 680 MessageParcel data4; 681 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 682 data4.WriteParcelable(info.get()); 683 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_STOP, data4, reply, option), ERR_OK); 684 685 MessageParcel data5; 686 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 687 data5.WriteInt32(-1); 688 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_CONTINUOUS_TASK_STOP, data5, reply, option), 689 ERR_INVALID_DATA); 690 } 691 692 /** 693 * @tc.name: BackgroundTaskSubscriberStubTest_005 694 * @tc.desc: test BackgroundTaskSubscriberStub. 695 * @tc.type: FUNC 696 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 697 */ 698 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_005, TestSize.Level1) 699 { 700 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 701 MessageParcel reply; 702 MessageOption option; 703 std::shared_ptr<ResourceCallbackInfo> info = std::make_shared<ResourceCallbackInfo>(); 704 MessageParcel data1; 705 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 706 EXPECT_NE(subscirberStub.OnRemoteRequest(static_cast<uint32_t>(OHOS::BackgroundTaskMgr:: 707 IBackgroundTaskSubscriberIpcCode::COMMAND_ON_APP_EFFICIENCY_RESOURCES_APPLY), data1, reply, option), ERR_OK); 708 MessageParcel data2; 709 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 710 data2.WriteParcelable(info.get()); 711 EXPECT_EQ(subscirberStub.OnRemoteRequest(static_cast<uint32_t>(OHOS::BackgroundTaskMgr:: 712 IBackgroundTaskSubscriberIpcCode::COMMAND_ON_APP_EFFICIENCY_RESOURCES_APPLY), data2, reply, option), ERR_OK); 713 714 MessageParcel data3; 715 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 716 EXPECT_NE(subscirberStub.OnRemoteRequest(static_cast<uint32_t>(OHOS::BackgroundTaskMgr:: 717 IBackgroundTaskSubscriberIpcCode::COMMAND_ON_APP_EFFICIENCY_RESOURCES_RESET), data3, reply, option), ERR_OK); 718 MessageParcel data4; 719 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 720 data4.WriteParcelable(info.get()); 721 EXPECT_EQ(subscirberStub.OnRemoteRequest(static_cast<uint32_t>(OHOS::BackgroundTaskMgr:: 722 IBackgroundTaskSubscriberIpcCode::COMMAND_ON_APP_EFFICIENCY_RESOURCES_RESET), data4, reply, option), ERR_OK); 723 724 MessageParcel data5; 725 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 726 EXPECT_NE(subscirberStub.OnRemoteRequest(static_cast<uint32_t>(OHOS::BackgroundTaskMgr:: 727 IBackgroundTaskSubscriberIpcCode::COMMAND_ON_PROC_EFFICIENCY_RESOURCES_APPLY), data5, reply, option), ERR_OK); 728 MessageParcel data6; 729 data6.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 730 data6.WriteParcelable(info.get()); 731 732 MessageParcel data7; 733 data7.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 734 EXPECT_NE(subscirberStub.OnRemoteRequest(static_cast<uint32_t>(OHOS::BackgroundTaskMgr:: 735 IBackgroundTaskSubscriberIpcCode::COMMAND_ON_PROC_EFFICIENCY_RESOURCES_RESET), data7, reply, option), ERR_OK); 736 MessageParcel data8; 737 data8.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 738 data8.WriteParcelable(info.get()); 739 EXPECT_EQ(subscirberStub.OnRemoteRequest(static_cast<uint32_t>(OHOS::BackgroundTaskMgr:: 740 IBackgroundTaskSubscriberIpcCode::COMMAND_ON_PROC_EFFICIENCY_RESOURCES_RESET), data8, reply, option), ERR_OK); 741 } 742 743 /** 744 * @tc.name: BackgroundTaskSubscriberStubTest_006 745 * @tc.desc: test BackgroundTaskSubscriberStub. 746 * @tc.type: FUNC 747 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 748 */ 749 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_006, TestSize.Level1) 750 { 751 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 752 MessageParcel reply; 753 MessageOption option; 754 MessageParcel data1; 755 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 756 EXPECT_EQ(subscirberStub.OnRemoteRequest(static_cast<uint32_t>(OHOS::BackgroundTaskMgr:: 757 IBackgroundTaskSubscriberIpcCode::COMMAND_GET_FLAG), data1, reply, option), ERR_OK); 758 } 759 760 /** 761 * @tc.name: ExpiredCallbackProxyTest_001 762 * @tc.desc: test ExpiredCallbackProxy. 763 * @tc.type: FUNC 764 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 765 */ 766 HWTEST_F(BgTaskFrameworkUnitTest, ExpiredCallbackProxyTest_001, TestSize.Level1) 767 { 768 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub()); 769 ExpiredCallbackProxy proxy1 = ExpiredCallbackProxy(nullptr); 770 ExpiredCallbackProxy proxy2 = ExpiredCallbackProxy(expiredCallbackStub->AsObject()); 771 proxy1.OnExpired(); 772 proxy2.OnExpired(); 773 EXPECT_NE(expiredCallbackStub, nullptr); 774 } 775 776 /** 777 * @tc.name: ExpiredCallbackStubTest_001 778 * @tc.desc: test ExpiredCallbackStub. 779 * @tc.type: FUNC 780 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 781 */ 782 HWTEST_F(BgTaskFrameworkUnitTest, ExpiredCallbackStubTest_001, TestSize.Level1) 783 { 784 TestExpiredCallbackStub expiredCallbackStub = TestExpiredCallbackStub(); 785 MessageParcel reply; 786 MessageOption option; 787 std::u16string descriptor = u"test"; 788 MessageParcel data1; 789 data1.WriteInterfaceToken(descriptor); 790 EXPECT_NE(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION, data1, reply, option), ERR_OK); 791 MessageParcel data2; 792 data2.WriteInterfaceToken(TestExpiredCallbackStub::GetDescriptor()); 793 EXPECT_NE(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION + 1, data2, reply, option), ERR_OK); 794 MessageParcel data3; 795 data3.WriteInterfaceToken(TestExpiredCallbackStub::GetDescriptor()); 796 EXPECT_EQ(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION, data3, reply, option), ERR_OK); 797 } 798 799 /** 800 * @tc.name: SetBgTaskConfig_001 801 * @tc.desc: test SetBgTaskConfig 802 * @tc.type: FUNC 803 * @tc.require: issueIAULHW 804 */ 805 HWTEST_F(BgTaskFrameworkUnitTest, SetBgTaskConfig_001, TestSize.Level1) 806 { 807 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 808 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 809 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->SetBgTaskConfig("", 1), 810 ERR_BGTASK_SERVICE_NOT_CONNECTED); 811 SystemAbilityManagerClient::GetInstance().action_ = ""; 812 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->SetBgTaskConfig("", 1), 813 ERR_OK); 814 } 815 816 /** 817 * @tc.name: RequestGetContinuousTasksByUidForInner_001 818 * @tc.desc: test RequestGetContinuousTasksByUidForInner 819 * @tc.type: FUNC 820 * @tc.require: issueIBY0DN 821 */ 822 HWTEST_F(BgTaskFrameworkUnitTest, RequestGetContinuousTasksByUidForInner_001, TestSize.Level1) 823 { 824 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 825 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 826 std::vector<std::shared_ptr<ContinuousTaskInfo>> list; 827 int32_t uid = -1; 828 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()-> 829 RequestGetContinuousTasksByUidForInner(uid, list), ERR_BGTASK_SERVICE_NOT_CONNECTED); 830 831 SystemAbilityManagerClient::GetInstance().action_ = ""; 832 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()-> 833 RequestGetContinuousTasksByUidForInner(uid, list), ERR_BGTASK_INVALID_UID); 834 835 uid = 1; 836 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()-> 837 RequestGetContinuousTasksByUidForInner(uid, list), ERR_OK); 838 } 839 840 /** 841 * @tc.name: RequestGetAllContinuousTasks_001 842 * @tc.desc: test RequestGetAllContinuousTasks 843 * @tc.type: FUNC 844 * @tc.require: issueIBY0DN 845 */ 846 HWTEST_F(BgTaskFrameworkUnitTest, RequestGetAllContinuousTasks_001, TestSize.Level1) 847 { 848 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 849 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 850 std::vector<std::shared_ptr<ContinuousTaskInfo>> list; 851 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestGetAllContinuousTasks(list), 852 ERR_BGTASK_SERVICE_NOT_CONNECTED); 853 854 SystemAbilityManagerClient::GetInstance().action_ = ""; 855 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestGetAllContinuousTasks(list), 856 ERR_BGTASK_PERMISSION_DENIED); 857 } 858 859 /** 860 * @tc.name: RequestGetAllContinuousTasks_002 861 * @tc.desc: test RequestGetAllContinuousTasks 862 * @tc.type: FUNC 863 * @tc.require: issuesICRZHF 864 */ 865 HWTEST_F(BgTaskFrameworkUnitTest, RequestGetAllContinuousTasks_002, TestSize.Level1) 866 { 867 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 868 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 869 std::vector<std::shared_ptr<ContinuousTaskInfo>> list; 870 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestGetAllContinuousTasks(list, false), 871 ERR_BGTASK_SERVICE_NOT_CONNECTED); 872 873 SystemAbilityManagerClient::GetInstance().action_ = ""; 874 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestGetAllContinuousTasks(list, false), 875 ERR_BGTASK_PERMISSION_DENIED); 876 } 877 878 /** 879 * @tc.name: GetAllTransientTasks_001 880 * @tc.desc: test GetAllTransientTasks. 881 * @tc.type: FUNC 882 * @tc.require: issueIC1HDY 883 */ 884 HWTEST_F(BgTaskFrameworkUnitTest, GetAllTransientTasks_001, TestSize.Level0) 885 { 886 int32_t remainingQuota = -1; 887 std::vector<std::shared_ptr<DelaySuspendInfo>> list; 888 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 889 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 890 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetAllTransientTasks(remainingQuota, list), 891 ERR_BGTASK_TRANSIENT_SERVICE_NOT_CONNECTED); 892 893 SystemAbilityManagerClient::GetInstance().action_ = ""; 894 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetAllTransientTasks(remainingQuota, list), 895 ERR_BGTASK_SERVICE_INNER_ERROR); 896 } 897 898 /** 899 * @tc.name: AVSessionNotifyUpdateNotification_001 900 * @tc.desc: test AVSessionNotifyUpdateNotification. 901 * @tc.type: FUNC 902 * @tc.require: issueIC9VN9 903 */ 904 HWTEST_F(BgTaskFrameworkUnitTest, AVSessionNotifyUpdateNotification_001, TestSize.Level1) 905 { 906 int32_t uid = -1; 907 int32_t pid = -1; 908 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 909 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 910 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()-> 911 AVSessionNotifyUpdateNotification(uid, pid, true), ERR_BGTASK_SERVICE_NOT_CONNECTED); 912 913 SystemAbilityManagerClient::GetInstance().action_ = ""; 914 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()-> 915 AVSessionNotifyUpdateNotification(uid, pid, true), ERR_BGTASK_CHECK_TASK_PARAM); 916 } 917 } 918 } 919