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_APP_TRANSIENT_TASK_START = 5; 51 constexpr uint32_t ON_APP_TRANSIENT_TASK_END = 6; 52 constexpr uint32_t ON_CONTINUOUS_TASK_START = 7; 53 constexpr uint32_t ON_CONTINUOUS_TASK_STOP = 8; 54 constexpr uint32_t ON_APP_CONTINUOUS_TASK_STOP = 9; 55 constexpr uint32_t ON_APP_EFFICIENCY_RESOURCES_APPLY = 10; 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 void OnConnected() override {} OnDisconnected()81 void OnDisconnected() override {} OnTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo> & info)82 void OnTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo>& info) override {} OnAppTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo> & info)83 void OnAppTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo>& info) override {} OnAppTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo> & info)84 void OnAppTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo>& info) override {} OnTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo> & info)85 void OnTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo>& info) override {} OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)86 void OnContinuousTaskStart( 87 const std::shared_ptr<ContinuousTaskCallbackInfo> &continuousTaskCallbackInfo) override {} OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)88 void OnContinuousTaskStop( 89 const std::shared_ptr<ContinuousTaskCallbackInfo> &continuousTaskCallbackInfo) override {} OnAppContinuousTaskStop(int32_t uid)90 void OnAppContinuousTaskStop(int32_t uid) override {} OnAppEfficiencyResourcesApply(const std::shared_ptr<ResourceCallbackInfo> & resourceInfo)91 void OnAppEfficiencyResourcesApply(const std::shared_ptr<ResourceCallbackInfo> &resourceInfo) override {} OnAppEfficiencyResourcesReset(const std::shared_ptr<ResourceCallbackInfo> & resourceInfo)92 void OnAppEfficiencyResourcesReset(const std::shared_ptr<ResourceCallbackInfo> &resourceInfo) override {} OnProcEfficiencyResourcesApply(const std::shared_ptr<ResourceCallbackInfo> & resourceInfo)93 void OnProcEfficiencyResourcesApply(const std::shared_ptr<ResourceCallbackInfo> &resourceInfo) override {} OnProcEfficiencyResourcesReset(const std::shared_ptr<ResourceCallbackInfo> & resourceInfo)94 void OnProcEfficiencyResourcesReset(const std::shared_ptr<ResourceCallbackInfo> &resourceInfo) override {} 95 }; 96 97 class TestExpiredCallbackStub : public ExpiredCallbackStub { 98 public: OnExpired()99 void OnExpired() override {} 100 }; 101 102 /** 103 * @tc.name: BgTaskFrameworkUnitTest_001 104 * @tc.desc: test RequestSuspendDelay. 105 * @tc.type: FUNC 106 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 107 */ 108 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_001, TestSize.Level1) 109 { 110 DelayedSingleton<BackgroundTaskManager>::GetInstance()->backgroundTaskMgrProxy_ = nullptr; 111 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 112 std::shared_ptr<DelaySuspendInfo> delayInfo = std::make_shared<DelaySuspendInfo>(); 113 auto expiredCallback = std::make_shared<TestExpiredCallback>(); 114 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestSuspendDelay( 115 u"test", *expiredCallback, delayInfo), ERR_BGTASK_SERVICE_NOT_CONNECTED); 116 SystemAbilityManagerClient::GetInstance().action_ = ""; 117 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestSuspendDelay( 118 u"test", *expiredCallback, delayInfo), ERR_OK); 119 expiredCallback->Init(); 120 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestSuspendDelay( 121 u"test", *expiredCallback, delayInfo), ERR_OK); 122 } 123 124 /** 125 * @tc.name: BgTaskFrameworkUnitTest_002 126 * @tc.desc: test GetRemainingDelayTime. 127 * @tc.type: FUNC 128 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 129 */ 130 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_002, TestSize.Level1) 131 { 132 DelayedSingleton<BackgroundTaskManager>::GetInstance()->backgroundTaskMgrProxy_ = nullptr; 133 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 134 int32_t delayTime = -1; 135 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetRemainingDelayTime(-1, delayTime), 136 ERR_BGTASK_SERVICE_NOT_CONNECTED); 137 SystemAbilityManagerClient::GetInstance().action_ = ""; 138 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetRemainingDelayTime(-1, delayTime), ERR_OK); 139 } 140 141 /** 142 * @tc.name: BgTaskFrameworkUnitTest_003 143 * @tc.desc: test CancelSuspendDelay. 144 * @tc.type: FUNC 145 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 146 */ 147 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_003, TestSize.Level1) 148 { 149 DelayedSingleton<BackgroundTaskManager>::GetInstance()->backgroundTaskMgrProxy_ = nullptr; 150 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 151 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->CancelSuspendDelay(-1), 152 ERR_BGTASK_SERVICE_NOT_CONNECTED); 153 SystemAbilityManagerClient::GetInstance().action_ = ""; 154 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->CancelSuspendDelay(-1), ERR_OK); 155 } 156 157 /** 158 * @tc.name: BgTaskFrameworkUnitTest_004 159 * @tc.desc: test RequestStartBackgroundRunning. 160 * @tc.type: FUNC 161 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 162 */ 163 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_004, TestSize.Level1) 164 { 165 DelayedSingleton<BackgroundTaskManager>::GetInstance()->backgroundTaskMgrProxy_ = nullptr; 166 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 167 ContinuousTaskParam taskParam = ContinuousTaskParam(); 168 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStartBackgroundRunning(taskParam), 169 ERR_BGTASK_SERVICE_NOT_CONNECTED); 170 SystemAbilityManagerClient::GetInstance().action_ = ""; 171 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStartBackgroundRunning(taskParam), 172 ERR_OK); 173 } 174 175 /** 176 * @tc.name: BgTaskFrameworkUnitTest_005 177 * @tc.desc: test RequestStopBackgroundRunning. 178 * @tc.type: FUNC 179 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 180 */ 181 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_005, TestSize.Level1) 182 { 183 DelayedSingleton<BackgroundTaskManager>::GetInstance()->backgroundTaskMgrProxy_ = nullptr; 184 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 185 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStopBackgroundRunning("test", nullptr), 186 ERR_BGTASK_SERVICE_NOT_CONNECTED); 187 SystemAbilityManagerClient::GetInstance().action_ = ""; 188 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestStopBackgroundRunning("test", nullptr), 189 ERR_OK); 190 } 191 192 /** 193 * @tc.name: BgTaskFrameworkUnitTest_006 194 * @tc.desc: test SubscribeBackgroundTask. 195 * @tc.type: FUNC 196 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 197 */ 198 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskFrameworkUnitTest_006, TestSize.Level1) 199 { 200 DelayedSingleton<BackgroundTaskManager>::GetInstance()->backgroundTaskMgrProxy_ = nullptr; 201 TestBackgroundTaskSubscriber taskSubscriber = TestBackgroundTaskSubscriber(); 202 SystemAbilityManagerClient::GetInstance().action_ = "set_null"; 203 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->SubscribeBackgroundTask(taskSubscriber), 204 ERR_BGTASK_SERVICE_NOT_CONNECTED); 205 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->UnsubscribeBackgroundTask(taskSubscriber), 206 ERR_BGTASK_SERVICE_NOT_CONNECTED); 207 SystemAbilityManagerClient::GetInstance().action_ = ""; 208 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->SubscribeBackgroundTask(taskSubscriber), 209 ERR_OK); 210 SleepForFC(); 211 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->UnsubscribeBackgroundTask(taskSubscriber), 212 ERR_OK); 213 SleepForFC(); 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()->backgroundTaskMgrProxy_ = 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 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetTransientTaskApps(list), ERR_OK); 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()->backgroundTaskMgrProxy_ = 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()->backgroundTaskMgrProxy_ = 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()->backgroundTaskMgrProxy_ = 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()->backgroundTaskMgrProxy_ = 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()->backgroundTaskMgrProxy_ = 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()->backgroundTaskMgrProxy_ = nullptr; 328 SystemAbilityManagerClient::GetInstance().action_ = ""; 329 DelayedSingleton<BackgroundTaskManager>::GetInstance()->GetBackgroundTaskManagerProxy(); 330 EXPECT_NE(DelayedSingleton<BackgroundTaskManager>::GetInstance()->backgroundTaskMgrProxy_, nullptr); 331 DelayedSingleton<BackgroundTaskManager>::GetInstance()->ResetBackgroundTaskManagerProxy(); 332 EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->backgroundTaskMgrProxy_, 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()->backgroundTaskMgrProxy_ = 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: BackgroundTaskSubscriberProxyTest_001 355 * @tc.desc: test BackgroundTaskSubscriberProxy. 356 * @tc.type: FUNC 357 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 358 */ 359 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_001, TestSize.Level1) 360 { 361 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 362 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 363 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 364 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 365 subscirberProxy1.OnConnected(); 366 subscirberProxy2.OnConnected(); 367 subscirberProxy1.OnDisconnected(); 368 subscirberProxy2.OnDisconnected(); 369 EXPECT_NE(subscirberStub, nullptr); 370 } 371 372 /** 373 * @tc.name: BackgroundTaskSubscriberProxyTest_002 374 * @tc.desc: test BackgroundTaskSubscriberProxy. 375 * @tc.type: FUNC 376 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 377 */ 378 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_002, TestSize.Level1) 379 { 380 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 381 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 382 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 383 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 384 subscirberProxy1.OnTransientTaskStart(nullptr); 385 subscirberProxy2.OnTransientTaskStart(nullptr); 386 subscirberProxy1.OnTransientTaskEnd(nullptr); 387 subscirberProxy2.OnTransientTaskEnd(nullptr); 388 subscirberProxy1.OnAppTransientTaskStart(nullptr); 389 subscirberProxy2.OnAppTransientTaskStart(nullptr); 390 subscirberProxy1.OnAppTransientTaskEnd(nullptr); 391 subscirberProxy2.OnAppTransientTaskEnd(nullptr); 392 std::shared_ptr<TransientTaskAppInfo> info = std::make_shared<TransientTaskAppInfo>(); 393 subscirberProxy2.OnTransientTaskStart(info); 394 subscirberProxy2.OnTransientTaskEnd(info); 395 subscirberProxy2.OnAppTransientTaskStart(info); 396 subscirberProxy2.OnAppTransientTaskEnd(info); 397 EXPECT_NE(subscirberStub, nullptr); 398 } 399 400 /** 401 * @tc.name: BackgroundTaskSubscriberProxyTest_003 402 * @tc.desc: test BackgroundTaskSubscriberProxy. 403 * @tc.type: FUNC 404 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 405 */ 406 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_003, TestSize.Level1) 407 { 408 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 409 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 410 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 411 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 412 subscirberProxy1.OnContinuousTaskStart(nullptr); 413 subscirberProxy2.OnContinuousTaskStart(nullptr); 414 subscirberProxy1.OnContinuousTaskStop(nullptr); 415 subscirberProxy2.OnContinuousTaskStop(nullptr); 416 subscirberProxy1.OnAppContinuousTaskStop(-1); 417 subscirberProxy2.OnAppContinuousTaskStop(-1); 418 std::shared_ptr<ContinuousTaskCallbackInfo> info = std::make_shared<ContinuousTaskCallbackInfo>(); 419 subscirberProxy2.OnContinuousTaskStart(info); 420 subscirberProxy2.OnContinuousTaskStop(info); 421 EXPECT_NE(subscirberStub, nullptr); 422 } 423 424 /** 425 * @tc.name: BackgroundTaskSubscriberProxyTest_004 426 * @tc.desc: test BackgroundTaskSubscriberProxy. 427 * @tc.type: FUNC 428 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 429 */ 430 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_004, TestSize.Level1) 431 { 432 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 433 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 434 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 435 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 436 subscirberProxy1.OnAppEfficiencyResourcesApply(nullptr); 437 subscirberProxy2.OnAppEfficiencyResourcesApply(nullptr); 438 subscirberProxy1.OnAppEfficiencyResourcesReset(nullptr); 439 subscirberProxy2.OnAppEfficiencyResourcesReset(nullptr); 440 subscirberProxy1.OnProcEfficiencyResourcesApply(nullptr); 441 subscirberProxy2.OnProcEfficiencyResourcesApply(nullptr); 442 subscirberProxy1.OnProcEfficiencyResourcesReset(nullptr); 443 subscirberProxy2.OnProcEfficiencyResourcesReset(nullptr); 444 std::shared_ptr<ResourceCallbackInfo> info = std::make_shared<ResourceCallbackInfo>(); 445 subscirberProxy2.OnAppEfficiencyResourcesApply(info); 446 subscirberProxy2.OnAppEfficiencyResourcesReset(info); 447 subscirberProxy2.OnProcEfficiencyResourcesApply(info); 448 subscirberProxy2.OnProcEfficiencyResourcesReset(info); 449 EXPECT_NE(subscirberStub, nullptr); 450 } 451 452 /** 453 * @tc.name: BackgroundTaskSubscriberStubTest_001 454 * @tc.desc: test BackgroundTaskSubscriberStub. 455 * @tc.type: FUNC 456 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 457 */ 458 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_001, TestSize.Level1) 459 { 460 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 461 MessageParcel data1; 462 MessageParcel data2; 463 MessageParcel reply; 464 MessageOption option; 465 std::u16string descriptor = u"test"; 466 data1.WriteInterfaceToken(descriptor); 467 EXPECT_NE(subscirberStub.OnRemoteRequest(1, data1, reply, option), ERR_OK); 468 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 469 EXPECT_NE(subscirberStub.OnRemoteRequest(100, data2, reply, option), ERR_OK); 470 } 471 472 /** 473 * @tc.name: BackgroundTaskSubscriberStubTest_002 474 * @tc.desc: test BackgroundTaskSubscriberStub. 475 * @tc.type: FUNC 476 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 477 */ 478 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_002, TestSize.Level1) 479 { 480 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 481 MessageParcel reply; 482 MessageOption option; 483 MessageParcel data1; 484 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 485 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONNECTED, data1, reply, option), ERR_OK); 486 MessageParcel data2; 487 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 488 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_DISCONNECTED, data1, reply, option), ERR_OK); 489 } 490 491 /** 492 * @tc.name: BackgroundTaskSubscriberStubTest_003 493 * @tc.desc: test BackgroundTaskSubscriberStub. 494 * @tc.type: FUNC 495 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 496 */ 497 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_003, TestSize.Level1) 498 { 499 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 500 MessageParcel reply; 501 MessageOption option; 502 std::shared_ptr<TransientTaskAppInfo> info = std::make_shared<TransientTaskAppInfo>(); 503 MessageParcel data1; 504 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 505 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_START, data1, reply, option), ERR_OK); 506 MessageParcel data2; 507 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 508 info->Marshalling(data2); 509 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_START, data2, reply, option), ERR_OK); 510 511 MessageParcel data3; 512 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 513 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_END, data3, reply, option), ERR_OK); 514 MessageParcel data4; 515 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 516 info->Marshalling(data4); 517 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_END, data4, reply, option), ERR_OK); 518 519 MessageParcel data5; 520 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 521 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_START, data5, reply, option), ERR_OK); 522 MessageParcel data6; 523 data6.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 524 info->Marshalling(data6); 525 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_START, data6, reply, option), ERR_OK); 526 527 MessageParcel data7; 528 data7.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 529 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_END, data7, reply, option), ERR_OK); 530 MessageParcel data8; 531 data8.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 532 info->Marshalling(data8); 533 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_END, data8, reply, option), ERR_OK); 534 } 535 536 /** 537 * @tc.name: BackgroundTaskSubscriberStubTest_004 538 * @tc.desc: test BackgroundTaskSubscriberStub. 539 * @tc.type: FUNC 540 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 541 */ 542 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_004, TestSize.Level1) 543 { 544 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 545 MessageParcel reply; 546 MessageOption option; 547 std::shared_ptr<ContinuousTaskCallbackInfo> info = std::make_shared<ContinuousTaskCallbackInfo>(); 548 MessageParcel data1; 549 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 550 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_START, data1, reply, option), ERR_OK); 551 MessageParcel data2; 552 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 553 data2.WriteParcelable(info.get()); 554 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_START, data2, reply, option), ERR_OK); 555 556 MessageParcel data3; 557 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 558 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_STOP, data3, reply, option), ERR_OK); 559 MessageParcel data4; 560 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 561 data4.WriteParcelable(info.get()); 562 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_STOP, data4, reply, option), ERR_OK); 563 564 MessageParcel data5; 565 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 566 data5.WriteInt32(-1); 567 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_CONTINUOUS_TASK_STOP, data5, reply, option), ERR_OK); 568 } 569 570 /** 571 * @tc.name: BackgroundTaskSubscriberStubTest_005 572 * @tc.desc: test BackgroundTaskSubscriberStub. 573 * @tc.type: FUNC 574 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 575 */ 576 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_005, TestSize.Level1) 577 { 578 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 579 MessageParcel reply; 580 MessageOption option; 581 std::shared_ptr<ResourceCallbackInfo> info = std::make_shared<ResourceCallbackInfo>(); 582 MessageParcel data1; 583 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 584 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_EFFICIENCY_RESOURCES_APPLY, data1, reply, option), ERR_OK); 585 MessageParcel data2; 586 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 587 data2.WriteParcelable(info.get()); 588 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_EFFICIENCY_RESOURCES_APPLY, data2, reply, option), ERR_OK); 589 590 MessageParcel data3; 591 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 592 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_EFFICIENCY_RESOURCES_RESET, data3, reply, option), ERR_OK); 593 MessageParcel data4; 594 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 595 data4.WriteParcelable(info.get()); 596 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_EFFICIENCY_RESOURCES_RESET, data4, reply, option), ERR_OK); 597 598 MessageParcel data5; 599 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 600 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_APPLY, data5, reply, option), ERR_OK); 601 MessageParcel data6; 602 data6.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 603 data6.WriteParcelable(info.get()); 604 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_APPLY, data6, reply, option), ERR_OK); 605 606 MessageParcel data7; 607 data7.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 608 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_RESET, data7, reply, option), ERR_OK); 609 MessageParcel data8; 610 data8.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 611 data8.WriteParcelable(info.get()); 612 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_RESET, data8, reply, option), ERR_OK); 613 } 614 615 /** 616 * @tc.name: ExpiredCallbackProxyTest_001 617 * @tc.desc: test ExpiredCallbackProxy. 618 * @tc.type: FUNC 619 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 620 */ 621 HWTEST_F(BgTaskFrameworkUnitTest, ExpiredCallbackProxyTest_001, TestSize.Level1) 622 { 623 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub()); 624 ExpiredCallbackProxy proxy1 = ExpiredCallbackProxy(nullptr); 625 ExpiredCallbackProxy proxy2 = ExpiredCallbackProxy(expiredCallbackStub->AsObject()); 626 proxy1.OnExpired(); 627 proxy2.OnExpired(); 628 EXPECT_NE(expiredCallbackStub, nullptr); 629 } 630 631 /** 632 * @tc.name: ExpiredCallbackStubTest_001 633 * @tc.desc: test ExpiredCallbackStub. 634 * @tc.type: FUNC 635 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 636 */ 637 HWTEST_F(BgTaskFrameworkUnitTest, ExpiredCallbackStubTest_001, TestSize.Level1) 638 { 639 TestExpiredCallbackStub expiredCallbackStub = TestExpiredCallbackStub(); 640 MessageParcel reply; 641 MessageOption option; 642 std::u16string descriptor = u"test"; 643 MessageParcel data1; 644 data1.WriteInterfaceToken(descriptor); 645 EXPECT_NE(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION, data1, reply, option), ERR_OK); 646 MessageParcel data2; 647 data2.WriteInterfaceToken(TestExpiredCallbackStub::GetDescriptor()); 648 EXPECT_NE(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION + 1, data2, reply, option), ERR_OK); 649 MessageParcel data3; 650 data3.WriteInterfaceToken(TestExpiredCallbackStub::GetDescriptor()); 651 EXPECT_EQ(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION, data3, reply, option), ERR_OK); 652 } 653 654 /** 655 * @tc.name: BgTaskMgrLogWrapperTest_001 656 * @tc.desc: test BgTaskMgrLogWrapper. 657 * @tc.type: FUNC 658 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 659 */ 660 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskMgrLogWrapperTest_001, TestSize.Level1) 661 { 662 BgTaskMgrLogWrapper::SetLogLevel(BgTaskMgrLogLevel::INFO); 663 EXPECT_FALSE(BgTaskMgrLogWrapper::JudgeLevel(BgTaskMgrLogLevel::DEBUG)); 664 EXPECT_TRUE(BgTaskMgrLogWrapper::JudgeLevel(BgTaskMgrLogLevel::WARN)); 665 666 EXPECT_EQ(BgTaskMgrLogWrapper::GetBriefFileName(nullptr), ""); 667 EXPECT_EQ(BgTaskMgrLogWrapper::GetBriefFileName("test"), ""); 668 EXPECT_EQ(BgTaskMgrLogWrapper::GetBriefFileName("test/test"), "test"); 669 } 670 } 671 } 672