1 /* 2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #include <functional> 16 #include <gtest/gtest.h> 17 18 #include "workscheduler_srv_client.h" 19 #include "work_sched_errors.h" 20 #include <if_system_ability_manager.h> 21 #include <ipc_skeleton.h> 22 #include <iservice_registry.h> 23 #include <system_ability_definition.h> 24 25 using namespace testing::ext; 26 27 namespace OHOS { 28 namespace WorkScheduler { 29 class WorkSchedClientTest : public testing::Test { 30 public: SetUpTestCase()31 static void SetUpTestCase() {} TearDownTestCase()32 static void TearDownTestCase() {} SetUp()33 void SetUp() {} TearDown()34 void TearDown() {} 35 }; 36 37 /** 38 * @tc.name: WorkSchedClientTest_001 39 * @tc.desc: Test StartWork 40 * @tc.type: FUNC 41 * @tc.require: issueI5Y6YK 42 */ 43 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_001, TestSize.Level0) 44 { 45 WorkInfo workInfo = WorkInfo(); 46 auto ret = WorkSchedulerSrvClient::GetInstance().StartWork(workInfo); 47 EXPECT_NE(ret, ERR_OK); 48 } 49 50 /** 51 * @tc.name: WorkSchedClientTest_002 52 * @tc.desc: Test StopWork 53 * @tc.type: FUNC 54 * @tc.require: issueI5Y6YK 55 */ 56 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_002, TestSize.Level0) 57 { 58 WorkInfo workInfo = WorkInfo(); 59 auto ret = WorkSchedulerSrvClient::GetInstance().StopWork(workInfo); 60 EXPECT_NE(ret, ERR_OK); 61 } 62 63 /** 64 * @tc.name: WorkSchedClientTest_003 65 * @tc.desc: Test StopAndCancelWork 66 * @tc.type: FUNC 67 * @tc.require: issueI5Y6YK 68 */ 69 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_003, TestSize.Level0) 70 { 71 WorkInfo workInfo = WorkInfo(); 72 auto ret = WorkSchedulerSrvClient::GetInstance().StopAndCancelWork(workInfo); 73 EXPECT_NE(ret, ERR_OK); 74 } 75 76 /** 77 * @tc.name: WorkSchedClientTest_004 78 * @tc.desc: Test StopAndClearWorks 79 * @tc.type: FUNC 80 * @tc.require: issueI5Y6YK 81 */ 82 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_004, TestSize.Level0) 83 { 84 auto ret = WorkSchedulerSrvClient::GetInstance().StopAndClearWorks(); 85 EXPECT_EQ(ret, ERR_OK); 86 } 87 88 /** 89 * @tc.name: WorkSchedClientTest_005 90 * @tc.desc: Test IsLastWorkTimeout 91 * @tc.type: FUNC 92 * @tc.require: issueI5Y6YK 93 */ 94 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_005, TestSize.Level0) 95 { 96 int32_t workId = 1; 97 bool result; 98 ErrCode ret = WorkSchedulerSrvClient::GetInstance().IsLastWorkTimeout(workId, result); 99 EXPECT_NE(ret, ERR_OK); 100 } 101 102 /** 103 * @tc.name: WorkSchedClientTest_006 104 * @tc.desc: Test GetWorkStatus 105 * @tc.type: FUNC 106 * @tc.require: issueI5Y6YK 107 */ 108 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_006, TestSize.Level0) 109 { 110 int32_t workId = 1; 111 std::shared_ptr<WorkInfo> work; 112 ErrCode ret = WorkSchedulerSrvClient::GetInstance().GetWorkStatus(workId, work); 113 EXPECT_NE(ret, ERR_OK); 114 workId = -1; 115 ret = WorkSchedulerSrvClient::GetInstance().GetWorkStatus(workId, work); 116 EXPECT_NE(ret, ERR_OK); 117 } 118 119 /** 120 * @tc.name: WorkSchedClientTest_007 121 * @tc.desc: Test ObtainAllWorks 122 * @tc.type: FUNC 123 * @tc.require: issueI5Y6YK 124 */ 125 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_007, TestSize.Level0) 126 { 127 std::list<std::shared_ptr<WorkInfo>> workInfos; 128 ErrCode ret = WorkSchedulerSrvClient::GetInstance().ObtainAllWorks(workInfos); 129 EXPECT_EQ(ret, ERR_OK); 130 } 131 132 /** 133 * @tc.name: WorkSchedClientTest_008 134 * @tc.desc: Test OnRemoteDied and ResetProxy 135 * @tc.type: FUNC 136 * @tc.require: issueI5Y6YK 137 */ 138 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_008, TestSize.Level0) 139 { 140 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); 141 sptr<IRemoteObject> remoteObject_ = sam->CheckSystemAbility(WORK_SCHEDULE_SERVICE_ID); 142 sptr<IRemoteObject::DeathRecipient> deathRecipient_ = sptr<IRemoteObject::DeathRecipient> 143 (new WorkSchedulerSrvClient::WorkSchedulerDeathRecipient(WorkSchedulerSrvClient::GetInstance())); 144 deathRecipient_->OnRemoteDied(remoteObject_); 145 WorkSchedulerSrvClient::GetInstance().iWorkSchedService_ = nullptr; 146 deathRecipient_->OnRemoteDied(remoteObject_); 147 EXPECT_NE(remoteObject_, nullptr); 148 } 149 150 /** 151 * @tc.name: WorkSchedClientTest_009 152 * @tc.desc: Test OnRemoteDied and ResetProxy 153 * @tc.type: FUNC 154 * @tc.require: issueI5Y6YK 155 */ 156 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_009, TestSize.Level0) 157 { 158 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); 159 sptr<IRemoteObject> remoteObject_ = sam->CheckSystemAbility(WORK_SCHEDULE_SERVICE_ID); 160 sptr<IRemoteObject::DeathRecipient> deathRecipient_ = sptr<IRemoteObject::DeathRecipient> 161 (new WorkSchedulerSrvClient::WorkSchedulerDeathRecipient(WorkSchedulerSrvClient::GetInstance())); 162 deathRecipient_->OnRemoteDied(nullptr); 163 EXPECT_NE(remoteObject_, nullptr); 164 } 165 166 /** 167 * @tc.name: WorkSchedClientTest_010 168 * @tc.desc: Test PauseRunningWorks 169 * @tc.type: FUNC 170 * @tc.require: issue:#I992IA 171 */ 172 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_010, TestSize.Level0) 173 { 174 int32_t uid = -1; 175 ErrCode ret = WorkSchedulerSrvClient::GetInstance().PauseRunningWorks(uid); 176 EXPECT_EQ(ret, E_PARAM_ERROR); 177 } 178 179 /** 180 * @tc.name: WorkSchedClientTest_011 181 * @tc.desc: Test PauseRunningWorks 182 * @tc.type: FUNC 183 * @tc.require: issue:#I992IA 184 */ 185 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_011, TestSize.Level0) 186 { 187 int32_t uid = IPCSkeleton::GetCallingUid(); 188 ErrCode ret = WorkSchedulerSrvClient::GetInstance().PauseRunningWorks(uid); 189 EXPECT_EQ(ret, E_INVALID_PROCESS_NAME); 190 } 191 192 /** 193 * @tc.name: WorkSchedClientTest_012 194 * @tc.desc: Test ResumePausedWorks 195 * @tc.type: FUNC 196 * @tc.require: issue:#I992IA 197 */ 198 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_012, TestSize.Level0) 199 { 200 int32_t uid = -1; 201 ErrCode ret = WorkSchedulerSrvClient::GetInstance().ResumePausedWorks(uid); 202 EXPECT_EQ(ret, E_PARAM_ERROR); 203 } 204 205 /** 206 * @tc.name: WorkSchedClientTest_013 207 * @tc.desc: Test ResumePausedWorks 208 * @tc.type: FUNC 209 * @tc.require: issue:#I992IA 210 */ 211 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_013, TestSize.Level0) 212 { 213 int32_t uid = IPCSkeleton::GetCallingUid(); 214 ErrCode ret = WorkSchedulerSrvClient::GetInstance().ResumePausedWorks(uid); 215 EXPECT_EQ(ret, E_INVALID_PROCESS_NAME); 216 } 217 218 /** 219 * @tc.name: WorkSchedClientTest_014 220 * @tc.desc: Test GetAllRunningWorks 221 * @tc.type: FUNC 222 * @tc.require: issue:#I9EKGI 223 */ 224 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_014, TestSize.Level0) 225 { 226 std::list<std::shared_ptr<WorkInfo>> workInfos; 227 ErrCode ret = WorkSchedulerSrvClient::GetInstance().GetAllRunningWorks(workInfos); 228 EXPECT_EQ(ret, E_INVALID_PROCESS_NAME); 229 } 230 231 /** 232 * @tc.name: WorkSchedClientTest_015 233 * @tc.desc: Test SetWorkSchedulerConfig 234 * @tc.type: FUNC 235 * @tc.require: issue:#I9EKGI 236 */ 237 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_015, TestSize.Level0) 238 { 239 int32_t sourceType = 1; 240 std::string configData = ""; 241 ErrCode ret = WorkSchedulerSrvClient::GetInstance().SetWorkSchedulerConfig(configData, sourceType); 242 EXPECT_NE(ret, ERR_OK); 243 } 244 245 /** 246 * @tc.name: WorkSchedClientTest_016 247 * @tc.desc: Test ObtainWorksByUidAndWorkIdForInner 248 * @tc.type: FUNC 249 * @tc.require: issueIC1RS6 250 */ 251 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_016, TestSize.Level0) 252 { 253 std::list<std::shared_ptr<WorkInfo>> workInfos; 254 int32_t uid = -1; 255 ErrCode ret = ERR_OK; 256 ret = WorkSchedulerSrvClient::GetInstance().ObtainWorksByUidAndWorkIdForInner(uid, workInfos); 257 EXPECT_EQ(ret, E_PARAM_INVAILD_UID); 258 259 uid = 1; 260 ret = WorkSchedulerSrvClient::GetInstance().ObtainWorksByUidAndWorkIdForInner(uid, workInfos); 261 EXPECT_EQ(ret, ERR_OK); 262 } 263 264 /** 265 * @tc.name: WorkSchedClientTest_017 266 * @tc.desc: Test StartWorkForInner 267 * @tc.type: FUNC 268 * @tc.require: issue:#ICBWOI 269 */ 270 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_017, TestSize.Level0) 271 { 272 WorkInfo workInfo = WorkInfo(); 273 auto ret = WorkSchedulerSrvClient::GetInstance().StartWorkForInner(workInfo); 274 EXPECT_NE(ret, ERR_OK); 275 } 276 277 /** 278 * @tc.name: WorkSchedClientTest_018 279 * @tc.desc: Test StopWorkForInner 280 * @tc.type: FUNC 281 * @tc.require: issue:#ICBWOI 282 */ 283 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_018, TestSize.Level0) 284 { 285 WorkInfo workInfo = WorkInfo(); 286 auto ret = WorkSchedulerSrvClient::GetInstance().StopWorkForInner(workInfo); 287 EXPECT_NE(ret, ERR_OK); 288 } 289 } // namespace WorkScheduler 290 } // namespace OHOS 291