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 <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.Level1) 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.Level1) 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.Level1) 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.Level1) 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.Level1) 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.Level1) 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.Level1) 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.Level1) 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.Level1) 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 } 164 165 /** 166 * @tc.name: WorkSchedClientTest_010 167 * @tc.desc: Test PauseRunningWorks 168 * @tc.type: FUNC 169 * @tc.require: issue:#I992IA 170 */ 171 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_010, TestSize.Level1) 172 { 173 int32_t uid = -1; 174 ErrCode ret = WorkSchedulerSrvClient::GetInstance().PauseRunningWorks(uid); 175 EXPECT_EQ(ret, E_PARAM_ERROR); 176 } 177 178 /** 179 * @tc.name: WorkSchedClientTest_011 180 * @tc.desc: Test PauseRunningWorks 181 * @tc.type: FUNC 182 * @tc.require: issue:#I992IA 183 */ 184 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_011, TestSize.Level1) 185 { 186 int32_t uid = IPCSkeleton::GetCallingUid(); 187 ErrCode ret = WorkSchedulerSrvClient::GetInstance().PauseRunningWorks(uid); 188 EXPECT_EQ(ret, E_INVALID_PROCESS_NAME); 189 } 190 191 /** 192 * @tc.name: WorkSchedClientTest_012 193 * @tc.desc: Test ResumePausedWorks 194 * @tc.type: FUNC 195 * @tc.require: issue:#I992IA 196 */ 197 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_012, TestSize.Level1) 198 { 199 int32_t uid = -1; 200 ErrCode ret = WorkSchedulerSrvClient::GetInstance().ResumePausedWorks(uid); 201 EXPECT_EQ(ret, E_PARAM_ERROR); 202 } 203 204 /** 205 * @tc.name: WorkSchedClientTest_013 206 * @tc.desc: Test ResumePausedWorks 207 * @tc.type: FUNC 208 * @tc.require: issue:#I992IA 209 */ 210 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_013, TestSize.Level1) 211 { 212 int32_t uid = IPCSkeleton::GetCallingUid(); 213 ErrCode ret = WorkSchedulerSrvClient::GetInstance().ResumePausedWorks(uid); 214 EXPECT_EQ(ret, E_INVALID_PROCESS_NAME); 215 } 216 217 /** 218 * @tc.name: WorkSchedClientTest_014 219 * @tc.desc: Test GetAllRunningWorks 220 * @tc.type: FUNC 221 * @tc.require: issue:#I9EKGI 222 */ 223 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_014, TestSize.Level1) 224 { 225 std::list<std::shared_ptr<WorkInfo>> workInfos; 226 ErrCode ret = WorkSchedulerSrvClient::GetInstance().GetAllRunningWorks(workInfos); 227 EXPECT_EQ(ret, E_INVALID_PROCESS_NAME); 228 } 229 230 /** 231 * @tc.name: WorkSchedClientTest_015 232 * @tc.desc: Test SetWorkSchedulerConfig 233 * @tc.type: FUNC 234 * @tc.require: issue:#I9EKGI 235 */ 236 HWTEST_F(WorkSchedClientTest, WorkSchedClientTest_015, TestSize.Level1) 237 { 238 int32_t sourceType = 1; 239 std::string configData = ""; 240 ErrCode ret = WorkSchedulerSrvClient::GetInstance().SetWorkSchedulerConfig(configData, sourceType); 241 EXPECT_NE(ret, ERR_OK); 242 } 243 } // namespace WorkScheduler 244 } // namespace OHOS 245