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 #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_param.h" 30 #include "delay_suspend_info.h" 31 #include "efficiency_resource_info.h" 32 #include "expired_callback.h" 33 #include "expired_callback_proxy.h" 34 #include "expired_callback_stub.h" 35 #include "iservice_registry.h" 36 #include "resource_callback_info.h" 37 #include "singleton.h" 38 #include "transient_task_app_info.h" 39 40 using namespace testing::ext; 41 42 namespace OHOS { 43 namespace BackgroundTaskMgr { 44 namespace { 45 constexpr int32_t SLEEP_TIME = 500; 46 constexpr uint32_t ON_CONNECTED = 1; 47 constexpr uint32_t ON_DISCONNECTED = 2; 48 constexpr uint32_t ON_TRANSIENT_TASK_START = 3; 49 constexpr uint32_t ON_TRANSIENT_TASK_END = 4; 50 constexpr uint32_t ON_TRANSIENT_TASK_ERR = 15; 51 constexpr uint32_t ON_APP_TRANSIENT_TASK_START = 5; 52 constexpr uint32_t ON_APP_TRANSIENT_TASK_END = 6; 53 constexpr uint32_t ON_CONTINUOUS_TASK_START = 7; 54 constexpr uint32_t ON_CONTINUOUS_TASK_STOP = 8; 55 constexpr uint32_t ON_APP_CONTINUOUS_TASK_STOP = 9; 56 constexpr uint32_t ON_APP_EFFICIENCY_RESOURCES_RESET = 11; 57 constexpr uint32_t ON_PROC_EFFICIENCY_RESOURCES_APPLY = 12; 58 constexpr uint32_t ON_PROC_EFFICIENCY_RESOURCES_RESET = 13; 59 } 60 class BgTaskFrameworkUnitTest : public testing::Test { 61 public: SetUpTestCase()62 static void SetUpTestCase() {} TearDownTestCase()63 static void TearDownTestCase() {} SetUp()64 void SetUp() override {} TearDown()65 void TearDown() override {} SleepForFC()66 inline void SleepForFC() 67 { 68 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME)); 69 } 70 }; 71 72 class TestExpiredCallback : public ExpiredCallback { 73 public: OnExpired()74 void OnExpired() override {} 75 }; 76 77 class TestBackgroundTaskSubscriber : public BackgroundTaskSubscriber {}; 78 79 class TestBackgroundTaskSubscriberStub : public BackgroundTaskSubscriberStub { OnConnected()80 ErrCode OnConnected() override {return ERR_OK;} OnDisconnected()81 ErrCode OnDisconnected() override {return ERR_OK;} OnTransientTaskStart(const TransientTaskAppInfo & info)82 ErrCode OnTransientTaskStart(const TransientTaskAppInfo& info) override {return ERR_OK;} OnAppTransientTaskStart(const TransientTaskAppInfo & info)83 ErrCode OnAppTransientTaskStart(const TransientTaskAppInfo& info) override {return ERR_OK;} OnAppTransientTaskEnd(const TransientTaskAppInfo & info)84 ErrCode OnAppTransientTaskEnd(const TransientTaskAppInfo& info) override {return ERR_OK;} OnTransientTaskEnd(const TransientTaskAppInfo & info)85 ErrCode OnTransientTaskEnd(const TransientTaskAppInfo& info) override {return ERR_OK;} OnTransientTaskErr(const TransientTaskAppInfo & info)86 ErrCode OnTransientTaskErr(const TransientTaskAppInfo& info) override {return ERR_OK;} OnContinuousTaskStart(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)87 ErrCode OnContinuousTaskStart( 88 const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;} OnContinuousTaskUpdate(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)89 ErrCode OnContinuousTaskUpdate( 90 const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;} OnContinuousTaskStop(const ContinuousTaskCallbackInfo & continuousTaskCallbackInfo)91 ErrCode OnContinuousTaskStop( 92 const ContinuousTaskCallbackInfo &continuousTaskCallbackInfo) override {return ERR_OK;} OnAppContinuousTaskStop(int32_t uid)93 ErrCode OnAppContinuousTaskStop(int32_t uid) override {return ERR_OK;} OnAppEfficiencyResourcesApply(const ResourceCallbackInfo & resourceInfo)94 ErrCode OnAppEfficiencyResourcesApply(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;} OnAppEfficiencyResourcesReset(const ResourceCallbackInfo & resourceInfo)95 ErrCode OnAppEfficiencyResourcesReset(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;} OnProcEfficiencyResourcesApply(const ResourceCallbackInfo & resourceInfo)96 ErrCode OnProcEfficiencyResourcesApply(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;} OnProcEfficiencyResourcesReset(const ResourceCallbackInfo & resourceInfo)97 ErrCode OnProcEfficiencyResourcesReset(const ResourceCallbackInfo &resourceInfo) override {return ERR_OK;} 98 }; 99 100 class TestExpiredCallbackStub : public ExpiredCallbackStub { 101 public: OnExpired()102 ErrCode OnExpired() override {return ERR_OK;} 103 }; 104 105 /** 106 * @tc.name: BgTaskFrameworkUnitTest_001 107 * @tc.desc: test RequestSuspendDelay. 108 * @tc.type: FUNC 109 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 110 */ 111 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_001, TestSize.Level1) 112 { 113 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 114 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 115 std::shared_ptr<DelaySuspendInfo> delayInfo = std::make_shared<DelaySuspendInfo>(); 116 auto expiredCallback = std::make_shared<TestExpiredCallback>(); 117 118 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestSuspendDelay( 119 u"test", *expiredCallback, delayInfo), ERR_BGTASK_SERVICE_NOT_CONNECTED); 120 SystemAbilityManagerClient::GetInstance().action_ = ""; 121 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestSuspendDelay( 122 u"test", *expiredCallback, delayInfo), ERR_OK); 123 expiredCallback->Init(); 124 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestSuspendDelay( 125 u"test", *expiredCallback, delayInfo), ERR_OK); 126 } 127 128 /** 129 * @tc.name: BgTaskFrameworkUnitTest_002 130 * @tc.desc: test GetRemainingDelayTime. 131 * @tc.type: FUNC 132 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 133 */ 134 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_002, TestSize.Level1) 135 { 136 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 137 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 138 int32_t delayTime = -1; 139 140 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetRemainingDelayTime(-1, delayTime), 141 ERR_BGTASK_SERVICE_NOT_CONNECTED); 142 SystemAbilityManagerClient::GetInstance().action_ = ""; 143 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetRemainingDelayTime(-1, delayTime), ERR_OK); 144 } 145 146 /** 147 * @tc.name: BgTaskFrameworkUnitTest_003 148 * @tc.desc: test CancelSuspendDelay. 149 * @tc.type: FUNC 150 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 151 */ 152 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_003, TestSize.Level1) 153 { 154 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 155 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 156 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->CancelSuspendDelay(-1), 157 ERR_BGTASK_SERVICE_NOT_CONNECTED); 158 SystemAbilityManagerClient::GetInstance().action_ = ""; 159 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->CancelSuspendDelay(-1), ERR_OK); 160 } 161 162 /** 163 * @tc.name: BgTaskFrameworkUnitTest_004 164 * @tc.desc: test RequestStartBackgroundRunning. 165 * @tc.type: FUNC 166 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 167 */ 168 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_004, TestSize.Level1) 169 { 170 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 171 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 172 ContinuousTaskParam taskParam = ContinuousTaskParam(); 173 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStartBackgroundRunning(taskParam), 174 ERR_BGTASK_SERVICE_NOT_CONNECTED); 175 SystemAbilityManagerClient::GetInstance().action_ = ""; 176 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStartBackgroundRunning(taskParam), 177 ERR_OK); 178 } 179 180 /** 181 * @tc.name: BgTaskFrameworkUnitTest_005 182 * @tc.desc: test RequestStopBackgroundRunning. 183 * @tc.type: FUNC 184 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V issueI99HSB 185 */ 186 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_005, TestSize.Level1) 187 { 188 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 189 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 190 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStopBackgroundRunning("test", nullptr, -1), 191 ERR_BGTASK_SERVICE_NOT_CONNECTED); 192 SystemAbilityManagerClient::GetInstance().action_ = ""; 193 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStopBackgroundRunning("test", nullptr, -1), 194 ERR_OK); 195 } 196 197 /** 198 * @tc.name: BgTaskFrameworkUnitTest_006 199 * @tc.desc: test SubscribeBackgroundTask. 200 * @tc.type: FUNC 201 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 202 */ 203 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_006, TestSize.Level1) 204 { 205 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 206 TestBackgroundTaskSubscriber taskSubscriber = TestBackgroundTaskSubscriber(); 207 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 208 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->SubscribeBackgroundTask(taskSubscriber), 209 ERR_BGTASK_SERVICE_NOT_CONNECTED); 210 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->UnsubscribeBackgroundTask(taskSubscriber), 211 ERR_BGTASK_SERVICE_NOT_CONNECTED); 212 SystemAbilityManagerClient::GetInstance().action_ = ""; 213 } 214 215 /** 216 * @tc.name: BgTaskFrameworkUnitTest_007 217 * @tc.desc: test GetTransientTaskApps. 218 * @tc.type: FUNC 219 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 220 */ 221 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_007, TestSize.Level1) 222 { 223 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 224 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 225 std::vector<std::shared_ptr<TransientTaskAppInfo>> list; 226 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetTransientTaskApps(list), 227 ERR_BGTASK_SERVICE_NOT_CONNECTED); 228 SystemAbilityManagerClient::GetInstance().action_ = ""; 229 DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetTransientTaskApps(list); 230 EXPECT_TRUE(true); 231 } 232 233 /** 234 * @tc.name: BgTaskFrameworkUnitTest_008 235 * @tc.desc: test GetContinuousTaskApps. 236 * @tc.type: FUNC 237 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 238 */ 239 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_008, TestSize.Level1) 240 { 241 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 242 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 243 std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> list; 244 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetContinuousTaskApps(list), 245 ERR_BGTASK_SERVICE_NOT_CONNECTED); 246 SystemAbilityManagerClient::GetInstance().action_ = ""; 247 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetContinuousTaskApps(list), ERR_OK); 248 } 249 250 /** 251 * @tc.name: BgTaskFrameworkUnitTest_009 252 * @tc.desc: test ApplyEfficiencyResources. 253 * @tc.type: FUNC 254 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 255 */ 256 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_009, TestSize.Level1) 257 { 258 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 259 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 260 EfficiencyResourceInfo resourceInfo = EfficiencyResourceInfo(); 261 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->ApplyEfficiencyResources( 262 resourceInfo), ERR_BGTASK_SERVICE_NOT_CONNECTED); 263 SystemAbilityManagerClient::GetInstance().action_ = ""; 264 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->ApplyEfficiencyResources( 265 resourceInfo), ERR_OK); 266 } 267 268 /** 269 * @tc.name: BgTaskFrameworkUnitTest_010 270 * @tc.desc: test ResetAllEfficiencyResources. 271 * @tc.type: FUNC 272 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 273 */ 274 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_0010, TestSize.Level1) 275 { 276 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 277 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 278 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->ResetAllEfficiencyResources(), 279 ERR_BGTASK_SERVICE_NOT_CONNECTED); 280 SystemAbilityManagerClient::GetInstance().action_ = ""; 281 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->ResetAllEfficiencyResources(), ERR_OK); 282 } 283 284 /** 285 * @tc.name: BgTaskFrameworkUnitTest_011 286 * @tc.desc: test GetEfficiencyResourcesInfos. 287 * @tc.type: FUNC 288 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 289 */ 290 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_011, TestSize.Level1) 291 { 292 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 293 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 294 std::vector<std::shared_ptr<ResourceCallbackInfo>> appList; 295 std::vector<std::shared_ptr<ResourceCallbackInfo>> procList; 296 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetEfficiencyResourcesInfos(appList, procList), 297 ERR_BGTASK_SERVICE_NOT_CONNECTED); 298 SystemAbilityManagerClient::GetInstance().action_ = ""; 299 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetEfficiencyResourcesInfos(appList, procList), 300 ERR_OK); 301 } 302 303 /** 304 * @tc.name: BgTaskFrameworkUnitTest_012 305 * @tc.desc: test StopContinuousTask. 306 * @tc.type: FUNC 307 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 308 */ 309 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_012, TestSize.Level1) 310 { 311 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 312 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 313 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->StopContinuousTask(1, 1, 1, ""), 314 ERR_BGTASK_SERVICE_NOT_CONNECTED); 315 SystemAbilityManagerClient::GetInstance().action_ = ""; 316 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->StopContinuousTask(1, 1, 1, ""), ERR_OK); 317 } 318 319 /** 320 * @tc.name: BgTaskFrameworkUnitTest_013 321 * @tc.desc: test GetBackgroundTaskManagerProxy. 322 * @tc.type: FUNC 323 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 324 */ 325 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_013, TestSize.Level1) 326 { 327 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 328 SystemAbilityManagerClient::GetInstance().action_ = ""; 329 DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetBackgroundTaskManagerProxy(); 330 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_, nullptr); 331 DelayedSingleton<BackgroundTaskManager>::GetInstance()->ResetBackgroundTaskManagerProxy(); 332 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_, nullptr); 333 } 334 335 /** 336 * @tc.name: BgTaskFrameworkUnitTest_014 337 * @tc.desc: test RequestBackgroundRunningForInner. 338 * @tc.type: FUNC 339 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 340 */ 341 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_014, TestSize.Level1) 342 { 343 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 344 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 345 ContinuousTaskParamForInner taskParam = ContinuousTaskParamForInner(); 346 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestBackgroundRunningForInner(taskParam), 347 ERR_BGTASK_SERVICE_NOT_CONNECTED); 348 SystemAbilityManagerClient::GetInstance().action_ = ""; 349 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestBackgroundRunningForInner(taskParam), 350 ERR_OK); 351 } 352 353 /** 354 * @tc.name: BgTaskFrameworkUnitTest_015 355 * @tc.desc: test PauseTransientTaskTimeForInner. 356 * @tc.type: FUNC 357 * @tc.require: issueI936BL 358 */ 359 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_015, TestSize.Level1) 360 { 361 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 362 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 363 int32_t uid = -1; 364 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->PauseTransientTaskTimeForInner(uid), 365 ERR_BGTASK_SERVICE_NOT_CONNECTED); 366 SystemAbilityManagerClient::GetInstance().action_ = ""; 367 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->PauseTransientTaskTimeForInner(uid), 368 ERR_OK); 369 } 370 371 /** 372 * @tc.name: BgTaskFrameworkUnitTest_016 373 * @tc.desc: test StartTransientTaskTimeForInner. 374 * @tc.type: FUNC 375 * @tc.require: issueI936BL 376 */ 377 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_016, TestSize.Level1) 378 { 379 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 380 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 381 int32_t uid = -1; 382 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->StartTransientTaskTimeForInner(uid), 383 ERR_BGTASK_SERVICE_NOT_CONNECTED); 384 SystemAbilityManagerClient::GetInstance().action_ = ""; 385 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->StartTransientTaskTimeForInner(uid), 386 ERR_OK); 387 } 388 389 /** 390 * @tc.name: BackgroundTaskSubscriberProxyTest_001 391 * @tc.desc: test BackgroundTaskSubscriberProxy. 392 * @tc.type: FUNC 393 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 394 */ 395 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_001, TestSize.Level1) 396 { 397 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 398 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 399 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 400 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 401 subscirberProxy1.OnConnected(); 402 subscirberProxy2.OnConnected(); 403 subscirberProxy1.OnDisconnected(); 404 subscirberProxy2.OnDisconnected(); 405 EXPECT_NE(subscirberStub, nullptr); 406 } 407 408 /** 409 * @tc.name: BackgroundTaskSubscriberProxyTest_002 410 * @tc.desc: test BackgroundTaskSubscriberProxy. 411 * @tc.type: FUNC 412 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 413 */ 414 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_002, TestSize.Level1) 415 { 416 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 417 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 418 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 419 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 420 std::shared_ptr<TransientTaskAppInfo> info = std::make_shared<TransientTaskAppInfo>(); 421 subscirberProxy2.OnTransientTaskStart(*info); 422 subscirberProxy2.OnTransientTaskEnd(*info); 423 subscirberProxy2.OnTransientTaskErr(*info); 424 subscirberProxy2.OnAppTransientTaskStart(*info); 425 subscirberProxy2.OnAppTransientTaskEnd(*info); 426 EXPECT_NE(subscirberStub, nullptr); 427 } 428 429 /** 430 * @tc.name: BackgroundTaskSubscriberProxyTest_003 431 * @tc.desc: test BackgroundTaskSubscriberProxy. 432 * @tc.type: FUNC 433 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 434 */ 435 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_003, TestSize.Level1) 436 { 437 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 438 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 439 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 440 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 441 subscirberProxy1.OnAppContinuousTaskStop(-1); 442 subscirberProxy2.OnAppContinuousTaskStop(-1); 443 std::shared_ptr<ContinuousTaskCallbackInfo> info = std::make_shared<ContinuousTaskCallbackInfo>(); 444 subscirberProxy2.OnContinuousTaskStart(*info); 445 subscirberProxy2.OnContinuousTaskStop(*info); 446 EXPECT_NE(subscirberStub, nullptr); 447 } 448 449 /** 450 * @tc.name: BackgroundTaskSubscriberProxyTest_004 451 * @tc.desc: test BackgroundTaskSubscriberProxy. 452 * @tc.type: FUNC 453 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 454 */ 455 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_004, TestSize.Level1) 456 { 457 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 458 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 459 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 460 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 461 std::shared_ptr<ResourceCallbackInfo> info = std::make_shared<ResourceCallbackInfo>(); 462 subscirberProxy2.OnAppEfficiencyResourcesApply(*info); 463 subscirberProxy2.OnAppEfficiencyResourcesReset(*info); 464 subscirberProxy2.OnProcEfficiencyResourcesApply(*info); 465 subscirberProxy2.OnProcEfficiencyResourcesReset(*info); 466 EXPECT_NE(subscirberStub, nullptr); 467 } 468 469 /** 470 * @tc.name: BackgroundTaskSubscriberStubTest_001 471 * @tc.desc: test BackgroundTaskSubscriberStub. 472 * @tc.type: FUNC 473 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 474 */ 475 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_001, TestSize.Level1) 476 { 477 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 478 MessageParcel data1; 479 MessageParcel data2; 480 MessageParcel reply; 481 MessageOption option; 482 std::u16string descriptor = u"test"; 483 data1.WriteInterfaceToken(descriptor); 484 EXPECT_NE(subscirberStub.OnRemoteRequest(1, data1, reply, option), ERR_OK); 485 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 486 EXPECT_NE(subscirberStub.OnRemoteRequest(100, data2, reply, option), ERR_OK); 487 } 488 489 /** 490 * @tc.name: BackgroundTaskSubscriberStubTest_002 491 * @tc.desc: test BackgroundTaskSubscriberStub. 492 * @tc.type: FUNC 493 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 494 */ 495 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_002, TestSize.Level1) 496 { 497 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 498 MessageParcel reply; 499 MessageOption option; 500 MessageParcel data1; 501 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 502 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONNECTED, data1, reply, option), ERR_OK); 503 MessageParcel data2; 504 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 505 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_DISCONNECTED, data1, reply, option), ERR_OK); 506 } 507 508 /** 509 * @tc.name: BackgroundTaskSubscriberStubTest_003 510 * @tc.desc: test BackgroundTaskSubscriberStub. 511 * @tc.type: FUNC 512 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 513 */ 514 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_003, TestSize.Level1) 515 { 516 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 517 MessageParcel reply; 518 MessageOption option; 519 std::shared_ptr<TransientTaskAppInfo> info = std::make_shared<TransientTaskAppInfo>(); 520 MessageParcel data1; 521 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 522 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_START, data1, reply, option), ERR_OK); 523 MessageParcel data2; 524 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 525 data2.WriteParcelable(info.get()); 526 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_START, data2, reply, option), ERR_OK); 527 528 MessageParcel data3; 529 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 530 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_END, data3, reply, option), ERR_OK); 531 MessageParcel data4; 532 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 533 data4.WriteParcelable(info.get()); 534 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_END, data4, reply, option), ERR_OK); 535 536 MessageParcel data9; 537 data9.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 538 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_ERR, data9, reply, option), ERR_OK); 539 MessageParcel data10; 540 data10.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 541 data10.WriteParcelable(info.get()); 542 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_ERR, data10, reply, option), ERR_OK); 543 544 MessageParcel data5; 545 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 546 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_START, data5, reply, option), ERR_OK); 547 MessageParcel data6; 548 data6.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 549 data6.WriteParcelable(info.get()); 550 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_START, data6, reply, option), ERR_OK); 551 552 MessageParcel data7; 553 data7.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 554 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_END, data7, reply, option), ERR_OK); 555 MessageParcel data8; 556 data8.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 557 data8.WriteParcelable(info.get()); 558 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_END, data8, reply, option), ERR_OK); 559 } 560 561 /** 562 * @tc.name: BackgroundTaskSubscriberStubTest_004 563 * @tc.desc: test BackgroundTaskSubscriberStub. 564 * @tc.type: FUNC 565 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 566 */ 567 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_004, TestSize.Level1) 568 { 569 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 570 MessageParcel reply; 571 MessageOption option; 572 std::shared_ptr<ContinuousTaskCallbackInfo> info = std::make_shared<ContinuousTaskCallbackInfo>(); 573 MessageParcel data1; 574 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 575 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_START, data1, reply, option), ERR_OK); 576 MessageParcel data2; 577 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 578 data2.WriteParcelable(info.get()); 579 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_START, data2, reply, option), ERR_OK); 580 581 MessageParcel data3; 582 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 583 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_STOP, data3, reply, option), ERR_OK); 584 MessageParcel data4; 585 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 586 data4.WriteParcelable(info.get()); 587 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_STOP, data4, reply, option), ERR_OK); 588 589 MessageParcel data5; 590 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 591 data5.WriteInt32(-1); 592 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_CONTINUOUS_TASK_STOP, data5, reply, option), 593 ERR_INVALID_DATA); 594 } 595 596 /** 597 * @tc.name: BackgroundTaskSubscriberStubTest_005 598 * @tc.desc: test BackgroundTaskSubscriberStub. 599 * @tc.type: FUNC 600 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 601 */ 602 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_005, TestSize.Level1) 603 { 604 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 605 MessageParcel reply; 606 MessageOption option; 607 std::shared_ptr<ResourceCallbackInfo> info = std::make_shared<ResourceCallbackInfo>(); 608 MessageParcel data1; 609 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 610 EXPECT_NE(subscirberStub.OnRemoteRequest(static_cast<uint32_t>(OHOS::BackgroundTaskMgr:: 611 IBackgroundTaskSubscriberIpcCode::COMMAND_ON_APP_EFFICIENCY_RESOURCES_APPLY), data1, reply, option), ERR_OK); 612 MessageParcel data2; 613 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 614 data2.WriteParcelable(info.get()); 615 EXPECT_EQ(subscirberStub.OnRemoteRequest(static_cast<uint32_t>(OHOS::BackgroundTaskMgr:: 616 IBackgroundTaskSubscriberIpcCode::COMMAND_ON_APP_EFFICIENCY_RESOURCES_APPLY), data2, reply, option), ERR_OK); 617 618 MessageParcel data3; 619 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 620 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_EFFICIENCY_RESOURCES_RESET, data3, reply, option), ERR_OK); 621 MessageParcel data4; 622 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 623 data4.WriteParcelable(info.get()); 624 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_EFFICIENCY_RESOURCES_RESET, data4, reply, option), ERR_OK); 625 626 MessageParcel data5; 627 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 628 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_APPLY, data5, reply, option), ERR_OK); 629 MessageParcel data6; 630 data6.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 631 data6.WriteParcelable(info.get()); 632 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_APPLY, data6, reply, option), ERR_OK); 633 634 MessageParcel data7; 635 data7.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 636 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_RESET, data7, reply, option), ERR_OK); 637 MessageParcel data8; 638 data8.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 639 data8.WriteParcelable(info.get()); 640 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_RESET, data8, reply, option), ERR_OK); 641 } 642 643 /** 644 * @tc.name: ExpiredCallbackProxyTest_001 645 * @tc.desc: test ExpiredCallbackProxy. 646 * @tc.type: FUNC 647 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 648 */ 649 HWTEST_F(BgTaskFrameworkUnitTest, ExpiredCallbackProxyTest_001, TestSize.Level1) 650 { 651 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub()); 652 ExpiredCallbackProxy proxy1 = ExpiredCallbackProxy(nullptr); 653 ExpiredCallbackProxy proxy2 = ExpiredCallbackProxy(expiredCallbackStub->AsObject()); 654 proxy1.OnExpired(); 655 proxy2.OnExpired(); 656 EXPECT_NE(expiredCallbackStub, nullptr); 657 } 658 659 /** 660 * @tc.name: ExpiredCallbackStubTest_001 661 * @tc.desc: test ExpiredCallbackStub. 662 * @tc.type: FUNC 663 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 664 */ 665 HWTEST_F(BgTaskFrameworkUnitTest, ExpiredCallbackStubTest_001, TestSize.Level1) 666 { 667 TestExpiredCallbackStub expiredCallbackStub = TestExpiredCallbackStub(); 668 MessageParcel reply; 669 MessageOption option; 670 std::u16string descriptor = u"test"; 671 MessageParcel data1; 672 data1.WriteInterfaceToken(descriptor); 673 EXPECT_NE(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION, data1, reply, option), ERR_OK); 674 MessageParcel data2; 675 data2.WriteInterfaceToken(TestExpiredCallbackStub::GetDescriptor()); 676 EXPECT_NE(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION + 1, data2, reply, option), ERR_OK); 677 MessageParcel data3; 678 data3.WriteInterfaceToken(TestExpiredCallbackStub::GetDescriptor()); 679 EXPECT_EQ(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION, data3, reply, option), ERR_OK); 680 } 681 682 /** 683 * @tc.name: SetBgTaskConfig_001 684 * @tc.desc: test SetBgTaskConfig 685 * @tc.type: FUNC 686 * @tc.require: issueIAULHW 687 */ 688 HWTEST_F(BgTaskFrameworkUnitTest, SetBgTaskConfig_001, TestSize.Level1) 689 { 690 DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr; 691 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 692 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->SetBgTaskConfig("", 1), 693 ERR_BGTASK_SERVICE_NOT_CONNECTED); 694 SystemAbilityManagerClient::GetInstance().action_ = ""; 695 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->SetBgTaskConfig("", 1), 696 ERR_OK); 697 } 698 } 699 } 700