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: BackgroundTaskSubscriberProxyTest_001 337 * @tc.desc: test BackgroundTaskSubscriberProxy. 338 * @tc.type: FUNC 339 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 340 */ 341 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_001, TestSize.Level1) 342 { 343 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 344 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 345 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 346 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 347 subscirberProxy1.OnConnected(); 348 subscirberProxy2.OnConnected(); 349 subscirberProxy1.OnDisconnected(); 350 subscirberProxy2.OnDisconnected(); 351 EXPECT_NE(subscirberStub, nullptr); 352 } 353 354 /** 355 * @tc.name: BackgroundTaskSubscriberProxyTest_002 356 * @tc.desc: test BackgroundTaskSubscriberProxy. 357 * @tc.type: FUNC 358 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 359 */ 360 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_002, TestSize.Level1) 361 { 362 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 363 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 364 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 365 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 366 subscirberProxy1.OnTransientTaskStart(nullptr); 367 subscirberProxy2.OnTransientTaskStart(nullptr); 368 subscirberProxy1.OnTransientTaskEnd(nullptr); 369 subscirberProxy2.OnTransientTaskEnd(nullptr); 370 subscirberProxy1.OnAppTransientTaskStart(nullptr); 371 subscirberProxy2.OnAppTransientTaskStart(nullptr); 372 subscirberProxy1.OnAppTransientTaskEnd(nullptr); 373 subscirberProxy2.OnAppTransientTaskEnd(nullptr); 374 std::shared_ptr<TransientTaskAppInfo> info = std::make_shared<TransientTaskAppInfo>(); 375 subscirberProxy2.OnTransientTaskStart(info); 376 subscirberProxy2.OnTransientTaskEnd(info); 377 subscirberProxy2.OnAppTransientTaskStart(info); 378 subscirberProxy2.OnAppTransientTaskEnd(info); 379 EXPECT_NE(subscirberStub, nullptr); 380 } 381 382 /** 383 * @tc.name: BackgroundTaskSubscriberProxyTest_003 384 * @tc.desc: test BackgroundTaskSubscriberProxy. 385 * @tc.type: FUNC 386 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 387 */ 388 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_003, TestSize.Level1) 389 { 390 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 391 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 392 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 393 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 394 subscirberProxy1.OnContinuousTaskStart(nullptr); 395 subscirberProxy2.OnContinuousTaskStart(nullptr); 396 subscirberProxy1.OnContinuousTaskStop(nullptr); 397 subscirberProxy2.OnContinuousTaskStop(nullptr); 398 subscirberProxy1.OnAppContinuousTaskStop(-1); 399 subscirberProxy2.OnAppContinuousTaskStop(-1); 400 std::shared_ptr<ContinuousTaskCallbackInfo> info = std::make_shared<ContinuousTaskCallbackInfo>(); 401 subscirberProxy2.OnContinuousTaskStart(info); 402 subscirberProxy2.OnContinuousTaskStop(info); 403 EXPECT_NE(subscirberStub, nullptr); 404 } 405 406 /** 407 * @tc.name: BackgroundTaskSubscriberProxyTest_004 408 * @tc.desc: test BackgroundTaskSubscriberProxy. 409 * @tc.type: FUNC 410 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 411 */ 412 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberProxyTest_004, TestSize.Level1) 413 { 414 sptr<TestBackgroundTaskSubscriberStub> subscirberStub 415 = sptr<TestBackgroundTaskSubscriberStub>(new TestBackgroundTaskSubscriberStub()); 416 BackgroundTaskSubscriberProxy subscirberProxy1 = BackgroundTaskSubscriberProxy(nullptr); 417 BackgroundTaskSubscriberProxy subscirberProxy2 = BackgroundTaskSubscriberProxy(subscirberStub->AsObject()); 418 subscirberProxy1.OnAppEfficiencyResourcesApply(nullptr); 419 subscirberProxy2.OnAppEfficiencyResourcesApply(nullptr); 420 subscirberProxy1.OnAppEfficiencyResourcesReset(nullptr); 421 subscirberProxy2.OnAppEfficiencyResourcesReset(nullptr); 422 subscirberProxy1.OnProcEfficiencyResourcesApply(nullptr); 423 subscirberProxy2.OnProcEfficiencyResourcesApply(nullptr); 424 subscirberProxy1.OnProcEfficiencyResourcesReset(nullptr); 425 subscirberProxy2.OnProcEfficiencyResourcesReset(nullptr); 426 std::shared_ptr<ResourceCallbackInfo> info = std::make_shared<ResourceCallbackInfo>(); 427 subscirberProxy2.OnAppEfficiencyResourcesApply(info); 428 subscirberProxy2.OnAppEfficiencyResourcesReset(info); 429 subscirberProxy2.OnProcEfficiencyResourcesApply(info); 430 subscirberProxy2.OnProcEfficiencyResourcesReset(info); 431 EXPECT_NE(subscirberStub, nullptr); 432 } 433 434 /** 435 * @tc.name: BackgroundTaskSubscriberStubTest_001 436 * @tc.desc: test BackgroundTaskSubscriberStub. 437 * @tc.type: FUNC 438 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 439 */ 440 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_001, TestSize.Level1) 441 { 442 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 443 MessageParcel data1; 444 MessageParcel data2; 445 MessageParcel reply; 446 MessageOption option; 447 std::u16string descriptor = u"test"; 448 data1.WriteInterfaceToken(descriptor); 449 EXPECT_NE(subscirberStub.OnRemoteRequest(1, data1, reply, option), ERR_OK); 450 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 451 EXPECT_NE(subscirberStub.OnRemoteRequest(100, data2, reply, option), ERR_OK); 452 } 453 454 /** 455 * @tc.name: BackgroundTaskSubscriberStubTest_002 456 * @tc.desc: test BackgroundTaskSubscriberStub. 457 * @tc.type: FUNC 458 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 459 */ 460 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_002, TestSize.Level1) 461 { 462 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 463 MessageParcel reply; 464 MessageOption option; 465 MessageParcel data1; 466 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 467 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONNECTED, data1, reply, option), ERR_OK); 468 MessageParcel data2; 469 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 470 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_DISCONNECTED, data1, reply, option), ERR_OK); 471 } 472 473 /** 474 * @tc.name: BackgroundTaskSubscriberStubTest_003 475 * @tc.desc: test BackgroundTaskSubscriberStub. 476 * @tc.type: FUNC 477 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 478 */ 479 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_003, TestSize.Level1) 480 { 481 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 482 MessageParcel reply; 483 MessageOption option; 484 std::shared_ptr<TransientTaskAppInfo> info = std::make_shared<TransientTaskAppInfo>(); 485 MessageParcel data1; 486 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 487 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_START, data1, reply, option), ERR_OK); 488 MessageParcel data2; 489 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 490 info->Marshalling(data2); 491 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_START, data2, reply, option), ERR_OK); 492 493 MessageParcel data3; 494 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 495 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_END, data3, reply, option), ERR_OK); 496 MessageParcel data4; 497 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 498 info->Marshalling(data4); 499 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_TRANSIENT_TASK_END, data4, reply, option), ERR_OK); 500 501 MessageParcel data5; 502 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 503 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_START, data5, reply, option), ERR_OK); 504 MessageParcel data6; 505 data6.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 506 info->Marshalling(data6); 507 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_START, data6, reply, option), ERR_OK); 508 509 MessageParcel data7; 510 data7.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 511 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_END, data7, reply, option), ERR_OK); 512 MessageParcel data8; 513 data8.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 514 info->Marshalling(data8); 515 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_TRANSIENT_TASK_END, data8, reply, option), ERR_OK); 516 } 517 518 /** 519 * @tc.name: BackgroundTaskSubscriberStubTest_004 520 * @tc.desc: test BackgroundTaskSubscriberStub. 521 * @tc.type: FUNC 522 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 523 */ 524 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_004, TestSize.Level1) 525 { 526 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 527 MessageParcel reply; 528 MessageOption option; 529 std::shared_ptr<ContinuousTaskCallbackInfo> info = std::make_shared<ContinuousTaskCallbackInfo>(); 530 MessageParcel data1; 531 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 532 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_START, data1, reply, option), ERR_OK); 533 MessageParcel data2; 534 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 535 data2.WriteParcelable(info.get()); 536 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_START, data2, reply, option), ERR_OK); 537 538 MessageParcel data3; 539 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 540 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_STOP, data3, reply, option), ERR_OK); 541 MessageParcel data4; 542 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 543 data4.WriteParcelable(info.get()); 544 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_CONTINUOUS_TASK_STOP, data4, reply, option), ERR_OK); 545 546 MessageParcel data5; 547 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 548 data5.WriteInt32(-1); 549 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_CONTINUOUS_TASK_STOP, data5, reply, option), ERR_OK); 550 } 551 552 /** 553 * @tc.name: BackgroundTaskSubscriberStubTest_005 554 * @tc.desc: test BackgroundTaskSubscriberStub. 555 * @tc.type: FUNC 556 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 557 */ 558 HWTEST_F(BgTaskFrameworkUnitTest, BackgroundTaskSubscriberStubTest_005, TestSize.Level1) 559 { 560 TestBackgroundTaskSubscriberStub subscirberStub = TestBackgroundTaskSubscriberStub(); 561 MessageParcel reply; 562 MessageOption option; 563 std::shared_ptr<ResourceCallbackInfo> info = std::make_shared<ResourceCallbackInfo>(); 564 MessageParcel data1; 565 data1.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 566 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_EFFICIENCY_RESOURCES_APPLY, data1, reply, option), ERR_OK); 567 MessageParcel data2; 568 data2.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 569 data2.WriteParcelable(info.get()); 570 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_EFFICIENCY_RESOURCES_APPLY, data2, reply, option), ERR_OK); 571 572 MessageParcel data3; 573 data3.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 574 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_APP_EFFICIENCY_RESOURCES_RESET, data3, reply, option), ERR_OK); 575 MessageParcel data4; 576 data4.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 577 data4.WriteParcelable(info.get()); 578 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_APP_EFFICIENCY_RESOURCES_RESET, data4, reply, option), ERR_OK); 579 580 MessageParcel data5; 581 data5.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 582 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_APPLY, data5, reply, option), ERR_OK); 583 MessageParcel data6; 584 data6.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 585 data6.WriteParcelable(info.get()); 586 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_APPLY, data6, reply, option), ERR_OK); 587 588 MessageParcel data7; 589 data7.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 590 EXPECT_NE(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_RESET, data7, reply, option), ERR_OK); 591 MessageParcel data8; 592 data8.WriteInterfaceToken(TestBackgroundTaskSubscriberStub::GetDescriptor()); 593 data8.WriteParcelable(info.get()); 594 EXPECT_EQ(subscirberStub.OnRemoteRequest(ON_PROC_EFFICIENCY_RESOURCES_RESET, data8, reply, option), ERR_OK); 595 } 596 597 /** 598 * @tc.name: ExpiredCallbackProxyTest_001 599 * @tc.desc: test ExpiredCallbackProxy. 600 * @tc.type: FUNC 601 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 602 */ 603 HWTEST_F(BgTaskFrameworkUnitTest, ExpiredCallbackProxyTest_001, TestSize.Level1) 604 { 605 sptr<TestExpiredCallbackStub> expiredCallbackStub = sptr<TestExpiredCallbackStub>(new TestExpiredCallbackStub()); 606 ExpiredCallbackProxy proxy1 = ExpiredCallbackProxy(nullptr); 607 ExpiredCallbackProxy proxy2 = ExpiredCallbackProxy(expiredCallbackStub->AsObject()); 608 proxy1.OnExpired(); 609 proxy2.OnExpired(); 610 EXPECT_NE(expiredCallbackStub, nullptr); 611 } 612 613 /** 614 * @tc.name: ExpiredCallbackStubTest_001 615 * @tc.desc: test ExpiredCallbackStub. 616 * @tc.type: FUNC 617 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 618 */ 619 HWTEST_F(BgTaskFrameworkUnitTest, ExpiredCallbackStubTest_001, TestSize.Level1) 620 { 621 TestExpiredCallbackStub expiredCallbackStub = TestExpiredCallbackStub(); 622 MessageParcel reply; 623 MessageOption option; 624 std::u16string descriptor = u"test"; 625 MessageParcel data1; 626 data1.WriteInterfaceToken(descriptor); 627 EXPECT_NE(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION, data1, reply, option), ERR_OK); 628 MessageParcel data2; 629 data2.WriteInterfaceToken(TestExpiredCallbackStub::GetDescriptor()); 630 EXPECT_NE(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION + 1, data2, reply, option), ERR_OK); 631 MessageParcel data3; 632 data3.WriteInterfaceToken(TestExpiredCallbackStub::GetDescriptor()); 633 EXPECT_EQ(expiredCallbackStub.OnRemoteRequest(FIRST_CALL_TRANSACTION, data3, reply, option), ERR_OK); 634 } 635 636 /** 637 * @tc.name: BgTaskMgrLogWrapperTest_001 638 * @tc.desc: test BgTaskMgrLogWrapper. 639 * @tc.type: FUNC 640 * @tc.require: issuesI5OD7X issueI5IRJK issueI4QT3W issueI4QU0V 641 */ 642 HWTEST_F(BgTaskFrameworkUnitTest, BgTaskMgrLogWrapperTest_001, TestSize.Level1) 643 { 644 BgTaskMgrLogWrapper::SetLogLevel(BgTaskMgrLogLevel::INFO); 645 EXPECT_FALSE(BgTaskMgrLogWrapper::JudgeLevel(BgTaskMgrLogLevel::DEBUG)); 646 EXPECT_TRUE(BgTaskMgrLogWrapper::JudgeLevel(BgTaskMgrLogLevel::WARN)); 647 648 EXPECT_EQ(BgTaskMgrLogWrapper::GetBriefFileName(nullptr), ""); 649 EXPECT_EQ(BgTaskMgrLogWrapper::GetBriefFileName("test"), ""); 650 EXPECT_EQ(BgTaskMgrLogWrapper::GetBriefFileName("test/test"), "test"); 651 } 652 } 653 } 654