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