1 /* 2 * Copyright (c) 2024 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 16 /** 17 * @tc.number: SUB_Service_HandleCurGroupBackupInfos_0000 18 * @tc.name: SUB_Service_HandleCurGroupBackupInfos_0000 19 * @tc.desc: 测试 HandleCurGroupBackupInfos 的正常/异常分支 20 * @tc.size: MEDIUM 21 * @tc.type: FUNC 22 * @tc.level Level 1 23 * @tc.require: issueIAKC3I 24 */ 25 HWTEST_F(ServiceTest, SUB_Service_HandleCurGroupBackupInfos_0000, TestSize.Level1) 26 { 27 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleCurGroupBackupInfos_0000"; 28 try { 29 vector<BJsonEntityCaps::BundleInfo> backupInfos = { 30 {.name = "bundleName", .appIndex = 0, .allToBackup = false, .versionName = ""} }; 31 map<string, vector<BJsonUtil::BundleDetailInfo>> bundleNameDetailMap; 32 map<string, bool> isClearDataFlags; 33 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); 34 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 35 EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); 36 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 37 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 38 EXPECT_CALL(*jsonUtil, FindBundleInfoByName(_, _, _, _)).WillOnce(Return(false)); 39 service->HandleCurGroupBackupInfos(backupInfos, bundleNameDetailMap, isClearDataFlags); 40 EXPECT_TRUE(true); 41 42 backupInfos[0].allToBackup = true; 43 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); 44 EXPECT_CALL(*jsonUtil, FindBundleInfoByName(_, _, _, _)).WillOnce(Return(false)); 45 service->HandleCurGroupBackupInfos(backupInfos, bundleNameDetailMap, isClearDataFlags); 46 EXPECT_TRUE(true); 47 48 backupInfos[0].allToBackup = true; 49 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); 50 EXPECT_CALL(*jsonUtil, FindBundleInfoByName(_, _, _, _)).WillOnce(Return(true)); 51 service->HandleCurGroupBackupInfos(backupInfos, bundleNameDetailMap, isClearDataFlags); 52 EXPECT_TRUE(true); 53 } catch (...) { 54 EXPECT_TRUE(false); 55 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleCurGroupBackupInfos."; 56 } 57 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleCurGroupBackupInfos_0000"; 58 } 59 60 /** 61 * @tc.number: SUB_Service_ServiceResultReport_0000 62 * @tc.name: SUB_Service_ServiceResultReport_0000 63 * @tc.desc: 测试 ServiceResultReport 的正常/异常分支 64 * @tc.size: MEDIUM 65 * @tc.type: FUNC 66 * @tc.level Level 1 67 * @tc.require: issueIAKC3I 68 */ 69 HWTEST_F(ServiceTest, SUB_Service_ServiceResultReport_0000, TestSize.Level1) 70 { 71 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ServiceResultReport_0000"; 72 try { 73 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); 74 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); 75 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); 76 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); 77 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 78 EXPECT_CALL(*srProxy, RestoreOnResultReport(_, _, _)).WillOnce(Return()); 79 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); 80 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 81 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 82 auto ret = service->ServiceResultReport("", BackupRestoreScenario::FULL_RESTORE, 0); 83 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 84 85 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); 86 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); 87 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); 88 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); 89 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 90 EXPECT_CALL(*srProxy, IncrementalRestoreOnResultReport(_, _, _)).WillOnce(Return()); 91 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); 92 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 93 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 94 ret = service->ServiceResultReport("", BackupRestoreScenario::INCREMENTAL_RESTORE, 0); 95 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 96 97 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); 98 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); 99 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); 100 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); 101 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 102 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 103 EXPECT_CALL(*srProxy, BackupOnResultReport(_, _)).WillOnce(Return()); 104 ret = service->ServiceResultReport("", BackupRestoreScenario::FULL_BACKUP, 0); 105 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 106 107 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); 108 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); 109 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); 110 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); 111 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 112 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 113 EXPECT_CALL(*srProxy, IncrementalBackupOnResultReport(_, _)).WillOnce(Return()); 114 ret = service->ServiceResultReport("", BackupRestoreScenario::INCREMENTAL_BACKUP, 0); 115 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 116 } catch (...) { 117 EXPECT_TRUE(false); 118 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ServiceResultReport."; 119 } 120 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ServiceResultReport_0000"; 121 } 122 123 /** 124 * @tc.number: SUB_Service_SAResultReport_0000 125 * @tc.name: SUB_Service_SAResultReport_0000 126 * @tc.desc: 测试 SAResultReport 的正常/异常分支 127 * @tc.size: MEDIUM 128 * @tc.type: FUNC 129 * @tc.level Level 1 130 * @tc.require: issueIAKC3I 131 */ 132 HWTEST_F(ServiceTest, SUB_Service_SAResultReport_0000, TestSize.Level1) 133 { 134 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SAResultReport_0000"; 135 try { 136 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 137 EXPECT_CALL(*srProxy, RestoreOnResultReport(_, _, _)).WillOnce(Return()); 138 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); 139 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 140 auto ret = service->SAResultReport("", "", 0, BackupRestoreScenario::FULL_RESTORE); 141 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 142 143 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 144 EXPECT_CALL(*srProxy, IncrementalRestoreOnResultReport(_, _, _)).WillOnce(Return()); 145 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); 146 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 147 ret = service->SAResultReport("", "", 0, BackupRestoreScenario::INCREMENTAL_RESTORE); 148 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 149 150 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy)); 151 EXPECT_CALL(*srProxy, BackupOnResultReport(_, _)).WillOnce(Return()); 152 EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return()); 153 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); 154 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 155 ret = service->SAResultReport("", "", 0, BackupRestoreScenario::FULL_BACKUP); 156 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 157 158 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 159 EXPECT_CALL(*srProxy, IncrementalBackupOnResultReport(_, _)).WillOnce(Return()); 160 EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); 161 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 162 ret = service->SAResultReport("", "", 0, BackupRestoreScenario::INCREMENTAL_BACKUP); 163 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 164 } catch (...) { 165 EXPECT_TRUE(false); 166 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SAResultReport."; 167 } 168 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SAResultReport_0000"; 169 } 170 171 /** 172 * @tc.number: SUB_Service_LaunchBackupSAExtension_0000 173 * @tc.name: SUB_Service_LaunchBackupSAExtension_0000 174 * @tc.desc: 测试 LaunchBackupSAExtension 的正常/异常分支 175 * @tc.size: MEDIUM 176 * @tc.type: FUNC 177 * @tc.level Level 1 178 * @tc.require: issueIAKC3I 179 */ 180 HWTEST_F(ServiceTest, SUB_Service_LaunchBackupSAExtension_0000, TestSize.Level1) 181 { 182 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_LaunchBackupSAExtension_0000"; 183 try { 184 BundleName bundleName; 185 EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); 186 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 187 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 188 auto ret = service->LaunchBackupSAExtension(bundleName); 189 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 190 191 shared_ptr<SABackupConnection> sa = nullptr; 192 EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); 193 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 194 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 195 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); 196 ret = service->LaunchBackupSAExtension(bundleName); 197 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); 198 199 sa = make_shared<SABackupConnection>(nullptr, nullptr, nullptr, nullptr); 200 EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); 201 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 202 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 203 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); 204 ret = service->LaunchBackupSAExtension(bundleName); 205 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 206 207 EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); 208 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); 209 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 210 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); 211 EXPECT_CALL(*saConnect, ConnectBackupSAExt(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); 212 ret = service->LaunchBackupSAExtension(bundleName); 213 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 214 215 EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); 216 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 217 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 218 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); 219 EXPECT_CALL(*saConnect, ConnectBackupSAExt(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); 220 ret = service->LaunchBackupSAExtension(bundleName); 221 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 222 } catch (...) { 223 EXPECT_TRUE(false); 224 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by LaunchBackupSAExtension."; 225 } 226 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_LaunchBackupSAExtension_0000"; 227 } 228 229 /** 230 * @tc.number: SUB_Service_GetFileHandle_0000 231 * @tc.name: SUB_Service_GetFileHandle_0000 232 * @tc.desc: 测试 GetFileHandle 的正常/异常分支 233 * @tc.size: MEDIUM 234 * @tc.type: FUNC 235 * @tc.level Level 1 236 * @tc.require: issueIAKC3I 237 */ 238 HWTEST_F(ServiceTest, SUB_Service_GetFileHandle_0000, TestSize.Level1) 239 { 240 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetFileHandle_0000"; 241 try { 242 string bundleName; 243 string fileName; 244 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); 245 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); 246 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); 247 EXPECT_CALL(*depManager, UpdateToRestoreBundleMap(_, _)).WillOnce(Return(true)); 248 auto ret = service->GetFileHandle(bundleName, fileName); 249 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 250 251 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); 252 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); 253 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); 254 EXPECT_CALL(*depManager, UpdateToRestoreBundleMap(_, _)).WillOnce(Return(false)); 255 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::WAIT)); 256 ret = service->GetFileHandle(bundleName, fileName); 257 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 258 259 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); 260 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); 261 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); 262 EXPECT_CALL(*depManager, UpdateToRestoreBundleMap(_, _)).WillOnce(Return(false)); 263 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); 264 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); 265 ret = service->GetFileHandle(bundleName, fileName); 266 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); 267 268 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); 269 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); 270 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); 271 EXPECT_CALL(*depManager, UpdateToRestoreBundleMap(_, _)).WillOnce(Return(false)); 272 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); 273 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); 274 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); 275 ret = service->GetFileHandle(bundleName, fileName); 276 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); 277 } catch (...) { 278 EXPECT_TRUE(false); 279 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetFileHandle."; 280 } 281 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetFileHandle_0000"; 282 } 283 284 /** 285 * @tc.number: SUB_Service_GetFileHandle_0100 286 * @tc.name: SUB_Service_GetFileHandle_0100 287 * @tc.desc: 测试 GetFileHandle 的正常/异常分支 288 * @tc.size: MEDIUM 289 * @tc.type: FUNC 290 * @tc.level Level 1 291 * @tc.require: issueIAKC3I 292 */ 293 HWTEST_F(ServiceTest, SUB_Service_GetFileHandle_0100, TestSize.Level1) 294 { 295 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetFileHandle_0100"; 296 try { 297 string bundleName; 298 string fileName; 299 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); 300 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); 301 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); 302 EXPECT_CALL(*depManager, UpdateToRestoreBundleMap(_, _)).WillOnce(Return(false)); 303 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); 304 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); 305 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); 306 EXPECT_CALL(*svcProxy, GetFileHandle(_, _)).WillOnce(Return(UniqueFd(-1))); 307 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 308 EXPECT_CALL(*srProxy, RestoreOnFileReady(_, _, _, _)).WillOnce(Return()); 309 auto ret = service->GetFileHandle(bundleName, fileName); 310 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 311 312 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)); 313 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); 314 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); 315 EXPECT_CALL(*depManager, UpdateToRestoreBundleMap(_, _)).WillOnce(Return(false)); 316 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); 317 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); 318 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); 319 EXPECT_CALL(*svcProxy, GetFileHandle(_, _)).WillOnce(DoAll(SetArgReferee<1>(1), Return(UniqueFd(-1)))); 320 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 321 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))) 322 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 323 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 324 EXPECT_CALL(*srProxy, RestoreOnFileReady(_, _, _, _)).WillOnce(Return()); 325 ret = service->GetFileHandle(bundleName, fileName); 326 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 327 } catch (...) { 328 EXPECT_TRUE(false); 329 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetFileHandle."; 330 } 331 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetFileHandle_0100"; 332 } 333 334 /** 335 * @tc.number: SUB_Service_OnBackupExtensionDied_0000 336 * @tc.name: SUB_Service_OnBackupExtensionDied_0000 337 * @tc.desc: 测试 OnBackupExtensionDied 的正常/异常分支 338 * @tc.size: MEDIUM 339 * @tc.type: FUNC 340 * @tc.level Level 1 341 * @tc.require: issueIAKC3I 342 */ 343 HWTEST_F(ServiceTest, SUB_Service_OnBackupExtensionDied_0000, TestSize.Level1) 344 { 345 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnBackupExtensionDied_0000"; 346 try { 347 service->isOccupyingSession_ = false; 348 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 349 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 350 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 351 service->OnBackupExtensionDied("", true); 352 EXPECT_TRUE(true); 353 354 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 355 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 356 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 357 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); 358 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); 359 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); 360 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 361 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 362 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 363 service->OnBackupExtensionDied("", false); 364 EXPECT_TRUE(true); 365 } catch (...) { 366 EXPECT_TRUE(false); 367 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnBackupExtensionDied."; 368 } 369 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnBackupExtensionDied_0000"; 370 } 371 372 /** 373 * @tc.number: SUB_Service_ExtConnectDied_0000 374 * @tc.name: SUB_Service_ExtConnectDied_0000 375 * @tc.desc: 测试 ExtConnectDied 的正常/异常分支 376 * @tc.size: MEDIUM 377 * @tc.type: FUNC 378 * @tc.level Level 1 379 * @tc.require: issueIAKC3I 380 */ 381 HWTEST_F(ServiceTest, SUB_Service_ExtConnectDied_0000, TestSize.Level1) 382 { 383 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ExtConnectDied_0000"; 384 try { 385 string callName; 386 service->isOccupyingSession_ = false; 387 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); 388 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); 389 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); 390 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 391 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 392 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 393 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 394 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 395 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 396 service->ExtConnectDied(callName); 397 EXPECT_TRUE(true); 398 399 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); 400 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); 401 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); 402 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(false)); 403 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 404 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 405 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 406 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 407 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 408 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 409 service->ExtConnectDied(callName); 410 EXPECT_TRUE(true); 411 412 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); 413 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); 414 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); 415 EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true)); 416 EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); 417 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 418 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 419 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 420 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 421 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 422 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 423 service->ExtConnectDied(callName); 424 EXPECT_TRUE(true); 425 } catch (...) { 426 EXPECT_TRUE(false); 427 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ExtConnectDied."; 428 } 429 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ExtConnectDied_0000"; 430 } 431 432 /** 433 * @tc.number: SUB_Service_ExtStart_0000 434 * @tc.name: SUB_Service_ExtStart_0000 435 * @tc.desc: 测试 ExtStart 的正常/异常分支 436 * @tc.size: MEDIUM 437 * @tc.type: FUNC 438 * @tc.level Level 1 439 * @tc.require: issueIAKC3I 440 */ 441 HWTEST_F(ServiceTest, SUB_Service_ExtStart_0000, TestSize.Level1) 442 { 443 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ExtStart_0000"; 444 try { 445 string callName; 446 shared_ptr<SABackupConnection> sa = make_shared<SABackupConnection>(nullptr, nullptr, nullptr, nullptr); 447 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 448 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 449 EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); 450 service->ExtStart(callName); 451 EXPECT_TRUE(true); 452 453 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)).WillOnce(Return(true)); 454 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 455 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 456 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 457 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); 458 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 459 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 460 service->ExtStart(callName); 461 EXPECT_TRUE(true); 462 463 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)).WillOnce(Return(true)); 464 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 465 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 466 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 467 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); 468 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); 469 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 470 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 471 service->ExtStart(callName); 472 EXPECT_TRUE(true); 473 474 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)).WillOnce(Return(true)); 475 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 476 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 477 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 478 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); 479 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); 480 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 481 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 482 service->ExtStart(callName); 483 EXPECT_TRUE(true); 484 } catch (...) { 485 EXPECT_TRUE(false); 486 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ExtStart."; 487 } 488 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ExtStart_0000"; 489 } 490 491 /** 492 * @tc.number: SUB_Service_ExtStart_0100 493 * @tc.name: SUB_Service_ExtStart_0100 494 * @tc.desc: 测试 ExtStart 的正常/异常分支 495 * @tc.size: MEDIUM 496 * @tc.type: FUNC 497 * @tc.level Level 1 498 * @tc.require: issueIAKC3I 499 */ 500 HWTEST_F(ServiceTest, SUB_Service_ExtStart_0100, TestSize.Level1) 501 { 502 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ExtStart_0100"; 503 try { 504 string callName; 505 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 506 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); 507 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); 508 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); 509 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); 510 EXPECT_CALL(*svcProxy, HandleBackup(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); 511 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 512 EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); 513 service->ExtStart(callName); 514 EXPECT_TRUE(true); 515 516 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)).WillOnce(Return(true)); 517 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)) 518 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 519 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 520 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); 521 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); 522 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); 523 EXPECT_CALL(*svcProxy, HandleBackup(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); 524 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 525 EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); 526 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 527 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 528 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 529 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 530 service->ExtStart(callName); 531 EXPECT_TRUE(true); 532 533 set<string> fileNameVec; 534 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 535 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 536 EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); 537 EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); 538 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); 539 EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); 540 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 541 EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return()); 542 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 543 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 544 EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec)); 545 service->ExtStart(callName); 546 EXPECT_TRUE(true); 547 } catch (...) { 548 EXPECT_TRUE(false); 549 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ExtStart."; 550 } 551 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ExtStart_0100"; 552 } 553 554 /** 555 * @tc.number: SUB_Service_Dump_0000 556 * @tc.name: SUB_Service_Dump_0000 557 * @tc.desc: 测试 Dump 的正常/异常分支 558 * @tc.size: MEDIUM 559 * @tc.type: FUNC 560 * @tc.level Level 1 561 * @tc.require: issueIAKC3I 562 */ 563 HWTEST_F(ServiceTest, SUB_Service_Dump_0000, TestSize.Level1) 564 { 565 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_Dump_0000"; 566 try { 567 vector<u16string> args; 568 auto ret = service->Dump(-1, args); 569 EXPECT_EQ(ret, -1); 570 571 ret = service->Dump(0, args); 572 EXPECT_EQ(ret, 0); 573 } catch (...) { 574 EXPECT_TRUE(false); 575 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by Dump."; 576 } 577 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_Dump_0000"; 578 } 579 580 /** 581 * @tc.number: SUB_Service_ReportOnExtConnectFailed_0000 582 * @tc.name: SUB_Service_ReportOnExtConnectFailed_0000 583 * @tc.desc: 测试 ReportOnExtConnectFailed 的正常/异常分支 584 * @tc.size: MEDIUM 585 * @tc.type: FUNC 586 * @tc.level Level 1 587 * @tc.require: issueIAKC3I 588 */ 589 HWTEST_F(ServiceTest, SUB_Service_ReportOnExtConnectFailed_0000, TestSize.Level1) 590 { 591 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ReportOnExtConnectFailed_0000"; 592 try { 593 string bundleName; 594 auto session_ = service->session_; 595 service->session_ = nullptr; 596 service->ReportOnExtConnectFailed(IServiceReverse::Scenario::UNDEFINED, bundleName, 0); 597 service->session_ = session_; 598 EXPECT_TRUE(true); 599 600 service->ReportOnExtConnectFailed(IServiceReverse::Scenario::UNDEFINED, bundleName, 0); 601 EXPECT_TRUE(true); 602 603 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); 604 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 605 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); 606 service->ReportOnExtConnectFailed(IServiceReverse::Scenario::BACKUP, bundleName, 0); 607 EXPECT_TRUE(true); 608 609 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); 610 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 611 EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); 612 service->ReportOnExtConnectFailed(IServiceReverse::Scenario::BACKUP, bundleName, 0); 613 EXPECT_TRUE(true); 614 615 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); 616 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); 617 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 618 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return()); 619 EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); 620 service->ReportOnExtConnectFailed(IServiceReverse::Scenario::RESTORE, bundleName, 0); 621 EXPECT_TRUE(true); 622 623 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); 624 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false)); 625 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 626 EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return()); 627 EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); 628 service->ReportOnExtConnectFailed(IServiceReverse::Scenario::RESTORE, bundleName, 0); 629 EXPECT_TRUE(true); 630 631 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); 632 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 633 EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return()); 634 EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); 635 service->ReportOnExtConnectFailed(IServiceReverse::Scenario::RESTORE, bundleName, 0); 636 EXPECT_TRUE(true); 637 } catch (...) { 638 EXPECT_TRUE(false); 639 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ReportOnExtConnectFailed."; 640 } 641 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ReportOnExtConnectFailed_0000"; 642 } 643 644 /** 645 * @tc.number: SUB_Service_NoticeClientFinish_0000 646 * @tc.name: SUB_Service_NoticeClientFinish_0000 647 * @tc.desc: 测试 NoticeClientFinish 的正常/异常分支 648 * @tc.size: MEDIUM 649 * @tc.type: FUNC 650 * @tc.level Level 1 651 * @tc.require: issueIAKC3I 652 */ 653 HWTEST_F(ServiceTest, SUB_Service_NoticeClientFinish_0000, TestSize.Level1) 654 { 655 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_NoticeClientFinish_0000"; 656 try { 657 string bundleName; 658 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 659 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 660 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 661 service->NoticeClientFinish(bundleName, 0); 662 EXPECT_TRUE(true); 663 664 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 665 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); 666 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); 667 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 668 EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return()); 669 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 670 service->NoticeClientFinish(bundleName, 0); 671 EXPECT_TRUE(true); 672 673 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 674 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 675 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); 676 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); 677 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 678 EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return()); 679 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 680 service->NoticeClientFinish(bundleName, 0); 681 EXPECT_TRUE(true); 682 683 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 684 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); 685 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); 686 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 687 EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return()); 688 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 689 service->NoticeClientFinish(bundleName, 0); 690 EXPECT_TRUE(true); 691 } catch (...) { 692 EXPECT_TRUE(false); 693 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by NoticeClientFinish."; 694 } 695 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_NoticeClientFinish_0000"; 696 } 697 698 /** 699 * @tc.number: SUB_Service_NoticeClientFinish_0100 700 * @tc.name: SUB_Service_NoticeClientFinish_0100 701 * @tc.desc: 测试 NoticeClientFinish 的正常/异常分支 702 * @tc.size: MEDIUM 703 * @tc.type: FUNC 704 * @tc.level Level 1 705 * @tc.require: issueIAKC3I 706 */ 707 HWTEST_F(ServiceTest, SUB_Service_NoticeClientFinish_0100, TestSize.Level1) 708 { 709 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_NoticeClientFinish_0100"; 710 try { 711 string bundleName; 712 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 713 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 714 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); 715 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false)); 716 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 717 EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return()); 718 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 719 service->NoticeClientFinish(bundleName, 0); 720 EXPECT_TRUE(true); 721 722 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 723 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 724 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); 725 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 726 EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return()); 727 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 728 service->NoticeClientFinish(bundleName, 0); 729 EXPECT_TRUE(true); 730 } catch (...) { 731 EXPECT_TRUE(false); 732 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by NoticeClientFinish."; 733 } 734 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_NoticeClientFinish_0100"; 735 } 736 737 /** 738 * @tc.number: SUB_Service_ExtConnectDone_0000 739 * @tc.name: SUB_Service_ExtConnectDone_0000 740 * @tc.desc: 测试 ExtConnectDone 的正常/异常分支 741 * @tc.size: MEDIUM 742 * @tc.type: FUNC 743 * @tc.level Level 1 744 * @tc.require: issueIAKC3I 745 */ 746 HWTEST_F(ServiceTest, SUB_Service_ExtConnectDone_0000, TestSize.Level1) 747 { 748 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ExtConnectDone_0000"; 749 try { 750 EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)).WillOnce(Return(false)); 751 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::WAIT)); 752 EXPECT_CALL(*cdConfig, InsertClearBundleRecord(_)).WillOnce(Return(true)); 753 service->ExtConnectDone(""); 754 EXPECT_TRUE(true); 755 756 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::CLEAN)); 757 service->ExtConnectDone(""); 758 EXPECT_TRUE(true); 759 760 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START)); 761 EXPECT_CALL(*cdConfig, FindClearBundleRecord(_)).WillOnce(Return(true)); 762 service->ExtConnectDone(""); 763 EXPECT_TRUE(true); 764 765 EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START)); 766 EXPECT_CALL(*cdConfig, FindClearBundleRecord(_)).WillOnce(Return(false)); 767 EXPECT_CALL(*cdConfig, InsertClearBundleRecord(_)).WillOnce(Return(true)); 768 service->ExtConnectDone(""); 769 EXPECT_TRUE(true); 770 } catch (...) { 771 EXPECT_TRUE(false); 772 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ExtConnectDone."; 773 } 774 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ExtConnectDone_0000"; 775 } 776 777 /** 778 * @tc.number: SUB_Service_ClearSessionAndSchedInfo_0000 779 * @tc.name: SUB_Service_ClearSessionAndSchedInfo_0000 780 * @tc.desc: 测试 ClearSessionAndSchedInfo 的正常/异常分支 781 * @tc.size: MEDIUM 782 * @tc.type: FUNC 783 * @tc.level Level 1 784 * @tc.require: issueIAKC3I 785 */ 786 HWTEST_F(ServiceTest, SUB_Service_ClearSessionAndSchedInfo_0000, TestSize.Level1) 787 { 788 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ClearSessionAndSchedInfo_0000"; 789 try { 790 string bundleName; 791 service->isOccupyingSession_ = false; 792 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 793 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 794 service->ClearSessionAndSchedInfo(bundleName); 795 EXPECT_TRUE(true); 796 797 service->isOccupyingSession_ = true; 798 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 799 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 800 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 801 service->ClearSessionAndSchedInfo(bundleName); 802 EXPECT_TRUE(true); 803 804 service->failedBundles_.clear(); 805 service->successBundlesNum_ = 0; 806 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 807 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 808 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); 809 service->ClearSessionAndSchedInfo(bundleName); 810 EXPECT_TRUE(true); 811 } catch (...) { 812 EXPECT_TRUE(false); 813 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ClearSessionAndSchedInfo."; 814 } 815 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ClearSessionAndSchedInfo_0000"; 816 } 817 818 /** 819 * @tc.number: SUB_Service_HandleRestoreDepsBundle_0000 820 * @tc.name: SUB_Service_HandleRestoreDepsBundle_0000 821 * @tc.desc: 测试 HandleRestoreDepsBundle 的正常/异常分支 822 * @tc.size: MEDIUM 823 * @tc.type: FUNC 824 * @tc.level Level 1 825 * @tc.require: issueIAKC3I 826 */ 827 HWTEST_F(ServiceTest, SUB_Service_HandleRestoreDepsBundle_0000, TestSize.Level1) 828 { 829 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleRestoreDepsBundle_0000"; 830 try { 831 string bundleName; 832 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 833 service->HandleRestoreDepsBundle(bundleName); 834 EXPECT_TRUE(true); 835 836 map<string, SvcRestoreDepsManager::RestoreInfo> bundleMap; 837 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 838 EXPECT_CALL(*depManager, GetRestoreBundleMap()).WillOnce(Return(bundleMap)); 839 service->HandleRestoreDepsBundle(bundleName); 840 EXPECT_TRUE(true); 841 842 bundleMap["bundleName"] = {.fileNames_ = {"name"}}; 843 vector<BJsonEntityCaps::BundleInfo> bundleInfos {{.name = "name"}}; 844 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 845 EXPECT_CALL(*depManager, GetRestoreBundleMap()).WillOnce(Return(bundleMap)); 846 EXPECT_CALL(*depManager, GetAllBundles()).WillOnce(Return(bundleInfos)); 847 service->HandleRestoreDepsBundle(bundleName); 848 EXPECT_TRUE(true); 849 850 bundleInfos.clear(); 851 bundleInfos = {{.name = "bundleName"}}; 852 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 853 EXPECT_CALL(*depManager, GetRestoreBundleMap()).WillOnce(Return(bundleMap)); 854 EXPECT_CALL(*depManager, GetAllBundles()).WillOnce(Return(bundleInfos)); 855 service->HandleRestoreDepsBundle(bundleName); 856 EXPECT_TRUE(true); 857 } catch (...) { 858 EXPECT_TRUE(false); 859 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by HandleRestoreDepsBundle."; 860 } 861 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_HandleRestoreDepsBundle_0000"; 862 } 863 864 865 /** 866 * @tc.number: SUB_Service_OnAllBundlesFinished_0000 867 * @tc.name: SUB_Service_OnAllBundlesFinished_0000 868 * @tc.desc: 测试 OnAllBundlesFinished 的正常/异常分支 869 * @tc.size: MEDIUM 870 * @tc.type: FUNC 871 * @tc.level Level 1 872 * @tc.require: issueIAKC3I 873 */ 874 HWTEST_F(ServiceTest, SUB_Service_OnAllBundlesFinished_0000, TestSize.Level1) 875 { 876 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnAllBundlesFinished_0000"; 877 try { 878 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); 879 service->OnAllBundlesFinished(0); 880 EXPECT_TRUE(true); 881 882 service->isInRelease_.store(false); 883 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); 884 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 885 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); 886 service->OnAllBundlesFinished(0); 887 EXPECT_TRUE(true); 888 889 service->isInRelease_.store(true); 890 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); 891 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 892 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); 893 service->OnAllBundlesFinished(0); 894 EXPECT_TRUE(true); 895 896 service->isInRelease_.store(true); 897 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); 898 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) 899 .WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 900 EXPECT_CALL(*session, CleanAndCheckIfNeedWait(_, _)).WillOnce(Return(true)); 901 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); 902 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 903 EXPECT_CALL(*srProxy, RestoreOnAllBundlesFinished(_)).WillOnce(Return()); 904 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); 905 service->OnAllBundlesFinished(0); 906 EXPECT_TRUE(true); 907 908 service->isInRelease_.store(false); 909 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); 910 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); 911 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); 912 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 913 EXPECT_CALL(*srProxy, IncrementalBackupOnAllBundlesFinished(_)).WillOnce(Return()); 914 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); 915 service->OnAllBundlesFinished(0); 916 EXPECT_TRUE(true); 917 } catch (...) { 918 EXPECT_TRUE(false); 919 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnAllBundlesFinished."; 920 } 921 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnAllBundlesFinished_0000"; 922 } 923 924 /** 925 * @tc.number: SUB_Service_OnAllBundlesFinished_0100 926 * @tc.name: SUB_Service_OnAllBundlesFinished_0100 927 * @tc.desc: 测试 OnAllBundlesFinished 的正常/异常分支 928 * @tc.size: MEDIUM 929 * @tc.type: FUNC 930 * @tc.level Level 1 931 * @tc.require: issueIAKC3I 932 */ 933 HWTEST_F(ServiceTest, SUB_Service_OnAllBundlesFinished_0100, TestSize.Level1) 934 { 935 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnAllBundlesFinished_0100"; 936 try { 937 service->isInRelease_.store(false); 938 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); 939 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); 940 EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); 941 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 942 EXPECT_CALL(*srProxy, BackupOnAllBundlesFinished(_)).WillOnce(Return()); 943 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); 944 service->OnAllBundlesFinished(0); 945 EXPECT_TRUE(true); 946 947 service->isInRelease_.store(false); 948 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); 949 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 950 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); 951 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); 952 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 953 EXPECT_CALL(*srProxy, IncrementalRestoreOnAllBundlesFinished(_)).WillOnce(Return()); 954 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); 955 service->OnAllBundlesFinished(0); 956 EXPECT_TRUE(true); 957 958 service->isInRelease_.store(false); 959 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); 960 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 961 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); 962 EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false)); 963 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 964 EXPECT_CALL(*srProxy, RestoreOnAllBundlesFinished(_)).WillOnce(Return()); 965 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); 966 service->OnAllBundlesFinished(0); 967 EXPECT_TRUE(true); 968 } catch (...) { 969 EXPECT_TRUE(false); 970 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnAllBundlesFinished."; 971 } 972 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnAllBundlesFinished_0100"; 973 } 974 975 /** 976 * @tc.number: SUB_Service_OnAllBundlesFinished_0200 977 * @tc.name: SUB_Service_OnAllBundlesFinished_0200 978 * @tc.desc: 测试 OnAllBundlesFinished 的正常/异常分支 979 * @tc.size: MEDIUM 980 * @tc.type: FUNC 981 * @tc.level Level 1 982 * @tc.require: issueIAKC3I 983 */ 984 HWTEST_F(ServiceTest, SUB_Service_OnAllBundlesFinished_0200, TestSize.Level1) 985 { 986 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnAllBundlesFinished_0200"; 987 try { 988 service->isInRelease_.store(false); 989 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); 990 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 991 EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); 992 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 993 EXPECT_CALL(*srProxy, RestoreOnAllBundlesFinished(_)).WillOnce(Return()); 994 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); 995 service->OnAllBundlesFinished(0); 996 EXPECT_TRUE(true); 997 998 service->isInRelease_.store(false); 999 EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); 1000 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1001 EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(false)); 1002 service->OnAllBundlesFinished(0); 1003 EXPECT_TRUE(true); 1004 } catch (...) { 1005 EXPECT_TRUE(false); 1006 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnAllBundlesFinished."; 1007 } 1008 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnAllBundlesFinished_0200"; 1009 } 1010 1011 /** 1012 * @tc.number: SUB_Service_OnStartSched_0000 1013 * @tc.name: SUB_Service_OnStartSched_0000 1014 * @tc.desc: 测试 OnStartSched 的正常/异常分支 1015 * @tc.size: MEDIUM 1016 * @tc.type: FUNC 1017 * @tc.level Level 1 1018 * @tc.require: issueIAKC3I 1019 */ 1020 HWTEST_F(ServiceTest, SUB_Service_OnStartSched_0000, TestSize.Level1) 1021 { 1022 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnStartSched_0000"; 1023 try { 1024 EXPECT_CALL(*session, IsOnOnStartSched()).WillOnce(Return(false)); 1025 service->OnStartSched(); 1026 EXPECT_TRUE(true); 1027 1028 EXPECT_CALL(*session, IsOnOnStartSched()).WillOnce(Return(true)); 1029 service->OnStartSched(); 1030 EXPECT_TRUE(true); 1031 } catch (...) { 1032 EXPECT_TRUE(false); 1033 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by OnStartSched."; 1034 } 1035 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_OnStartSched_0000"; 1036 } 1037 1038 /** 1039 * @tc.number: SUB_Service_SendStartAppGalleryNotify_0000 1040 * @tc.name: SUB_Service_SendStartAppGalleryNotify_0000 1041 * @tc.desc: 测试 SendStartAppGalleryNotify 的正常/异常分支 1042 * @tc.size: MEDIUM 1043 * @tc.type: FUNC 1044 * @tc.level Level 1 1045 * @tc.require: issueIAKC3I 1046 */ 1047 HWTEST_F(ServiceTest, SUB_Service_SendStartAppGalleryNotify_0000, TestSize.Level1) 1048 { 1049 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendStartAppGalleryNotify_0000"; 1050 try { 1051 BundleName bundleName; 1052 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 1053 service->SendStartAppGalleryNotify(bundleName); 1054 EXPECT_TRUE(true); 1055 1056 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 1057 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1058 service->SendStartAppGalleryNotify(bundleName); 1059 EXPECT_TRUE(true); 1060 1061 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 1062 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1063 EXPECT_CALL(*jdConfig, IfBundleNameInDisposalConfigFile(_)).WillOnce(Return(false)); 1064 service->SendStartAppGalleryNotify(bundleName); 1065 EXPECT_TRUE(true); 1066 1067 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 1068 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1069 EXPECT_CALL(*jdConfig, IfBundleNameInDisposalConfigFile(_)).WillOnce(Return(true)); 1070 EXPECT_CALL(*gallery, StartRestore(_, _)).WillOnce(Return(DisposeErr::OK)); 1071 service->SendStartAppGalleryNotify(bundleName); 1072 EXPECT_TRUE(true); 1073 } catch (...) { 1074 EXPECT_TRUE(false); 1075 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SendStartAppGalleryNotify."; 1076 } 1077 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SendStartAppGalleryNotify_0000"; 1078 } 1079 1080 /** 1081 * @tc.number: SUB_Service_SendEndAppGalleryNotify_0000 1082 * @tc.name: SUB_Service_SendEndAppGalleryNotify_0000 1083 * @tc.desc: 测试 SendEndAppGalleryNotify 的正常/异常分支 1084 * @tc.size: MEDIUM 1085 * @tc.type: FUNC 1086 * @tc.level Level 1 1087 * @tc.require: issueIAKC3I 1088 */ 1089 HWTEST_F(ServiceTest, SUB_Service_SendEndAppGalleryNotify_0000, TestSize.Level1) 1090 { 1091 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendEndAppGalleryNotify_0000"; 1092 try { 1093 BundleName bundleName; 1094 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 1095 service->SendEndAppGalleryNotify(bundleName); 1096 EXPECT_TRUE(true); 1097 1098 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 1099 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1100 service->SendEndAppGalleryNotify(bundleName); 1101 EXPECT_TRUE(true); 1102 1103 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 1104 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1105 EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::REQUEST_FAIL)); 1106 service->SendEndAppGalleryNotify(bundleName); 1107 EXPECT_TRUE(true); 1108 1109 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 1110 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1111 EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); 1112 EXPECT_CALL(*jdConfig, DeleteFromDisposalConfigFile(_)).WillOnce(Return(false)); 1113 service->SendEndAppGalleryNotify(bundleName); 1114 EXPECT_TRUE(true); 1115 1116 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 1117 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1118 EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); 1119 EXPECT_CALL(*jdConfig, DeleteFromDisposalConfigFile(_)).WillOnce(Return(true)); 1120 service->SendEndAppGalleryNotify(bundleName); 1121 EXPECT_TRUE(true); 1122 } catch (...) { 1123 EXPECT_TRUE(false); 1124 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SendEndAppGalleryNotify."; 1125 } 1126 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SendEndAppGalleryNotify_0000"; 1127 } 1128 1129 /** 1130 * @tc.number: SUB_Service_TryToClearDispose_0000 1131 * @tc.name: SUB_Service_TryToClearDispose_0000 1132 * @tc.desc: 测试 TryToClearDispose 的正常/异常分支 1133 * @tc.size: MEDIUM 1134 * @tc.type: FUNC 1135 * @tc.level Level 1 1136 * @tc.require: issueIAKC3I 1137 */ 1138 HWTEST_F(ServiceTest, SUB_Service_TryToClearDispose_0000, TestSize.Level1) 1139 { 1140 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_TryToClearDispose_0000"; 1141 try { 1142 BundleName bundleName; 1143 EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); 1144 EXPECT_CALL(*jdConfig, DeleteFromDisposalConfigFile(_)).WillOnce(Return(true)); 1145 service->TryToClearDispose(bundleName); 1146 EXPECT_TRUE(true); 1147 1148 EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::REQUEST_FAIL)) 1149 .WillOnce(Return(DisposeErr::OK)); 1150 EXPECT_CALL(*jdConfig, DeleteFromDisposalConfigFile(_)).WillOnce(Return(false)); 1151 service->TryToClearDispose(bundleName); 1152 EXPECT_TRUE(true); 1153 } catch (...) { 1154 EXPECT_TRUE(false); 1155 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by TryToClearDispose."; 1156 } 1157 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_TryToClearDispose_0000"; 1158 } 1159 1160 /** 1161 * @tc.number: SUB_Service_SendErrAppGalleryNotify_0000 1162 * @tc.name: SUB_Service_SendErrAppGalleryNotify_0000 1163 * @tc.desc: 测试 SendErrAppGalleryNotify 的正常/异常分支 1164 * @tc.size: MEDIUM 1165 * @tc.type: FUNC 1166 * @tc.level Level 1 1167 * @tc.require: issueIAKC3I 1168 */ 1169 HWTEST_F(ServiceTest, SUB_Service_SendErrAppGalleryNotify_0000, TestSize.Level1) 1170 { 1171 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendErrAppGalleryNotify_0000"; 1172 try { 1173 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1174 service->SendErrAppGalleryNotify(); 1175 EXPECT_TRUE(true); 1176 1177 vector<string> bundleNameList; 1178 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1179 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); 1180 service->SendErrAppGalleryNotify(); 1181 EXPECT_TRUE(true); 1182 1183 bundleNameList.emplace_back("bundleName"); 1184 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1185 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); 1186 EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); 1187 EXPECT_CALL(*jdConfig, DeleteFromDisposalConfigFile(_)).WillOnce(Return(true)); 1188 service->SendErrAppGalleryNotify(); 1189 EXPECT_TRUE(true); 1190 } catch (...) { 1191 EXPECT_TRUE(false); 1192 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SendErrAppGalleryNotify."; 1193 } 1194 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SendErrAppGalleryNotify_0000"; 1195 } 1196 1197 /** 1198 * @tc.number: SUB_Service_ClearDisposalOnSaStart_0000 1199 * @tc.name: SUB_Service_ClearDisposalOnSaStart_0000 1200 * @tc.desc: 测试 ClearDisposalOnSaStart 的正常/异常分支 1201 * @tc.size: MEDIUM 1202 * @tc.type: FUNC 1203 * @tc.level Level 1 1204 * @tc.require: issueIAKC3I 1205 */ 1206 HWTEST_F(ServiceTest, SUB_Service_ClearDisposalOnSaStart_0000, TestSize.Level1) 1207 { 1208 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ClearDisposalOnSaStart_0000"; 1209 try { 1210 vector<string> bundleNameList; 1211 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); 1212 service->ClearDisposalOnSaStart(); 1213 EXPECT_TRUE(true); 1214 1215 bundleNameList.emplace_back("bundleName"); 1216 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); 1217 EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); 1218 EXPECT_CALL(*jdConfig, DeleteFromDisposalConfigFile(_)).WillOnce(Return(true)); 1219 service->ClearDisposalOnSaStart(); 1220 EXPECT_TRUE(true); 1221 } catch (...) { 1222 EXPECT_TRUE(false); 1223 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by ClearDisposalOnSaStart."; 1224 } 1225 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_ClearDisposalOnSaStart_0000"; 1226 } 1227 1228 /** 1229 * @tc.number: SUB_Service_DeleteDisConfigFile_0000 1230 * @tc.name: SUB_Service_DeleteDisConfigFile_0000 1231 * @tc.desc: 测试 DeleteDisConfigFile 的正常/异常分支 1232 * @tc.size: MEDIUM 1233 * @tc.type: FUNC 1234 * @tc.level Level 1 1235 * @tc.require: issueIAKC3I 1236 */ 1237 HWTEST_F(ServiceTest, SUB_Service_DeleteDisConfigFile_0000, TestSize.Level1) 1238 { 1239 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_DeleteDisConfigFile_0000"; 1240 try { 1241 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1242 service->DeleteDisConfigFile(); 1243 EXPECT_TRUE(true); 1244 1245 vector<string> bundleNameList {"bundleName"}; 1246 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1247 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); 1248 service->DeleteDisConfigFile(); 1249 EXPECT_TRUE(true); 1250 1251 bundleNameList.clear(); 1252 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1253 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); 1254 EXPECT_CALL(*jdConfig, DeleteConfigFile()).WillOnce(Return(false)); 1255 service->DeleteDisConfigFile(); 1256 EXPECT_TRUE(true); 1257 1258 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1259 EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); 1260 EXPECT_CALL(*jdConfig, DeleteConfigFile()).WillOnce(Return(true)); 1261 service->DeleteDisConfigFile(); 1262 EXPECT_TRUE(true); 1263 } catch (...) { 1264 EXPECT_TRUE(false); 1265 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by DeleteDisConfigFile."; 1266 } 1267 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_DeleteDisConfigFile_0000"; 1268 } 1269 1270 /** 1271 * @tc.number: SUB_Service_SessionDeactive_0000 1272 * @tc.name: SUB_Service_SessionDeactive_0000 1273 * @tc.desc: 测试 SessionDeactive 的正常/异常分支 1274 * @tc.size: MEDIUM 1275 * @tc.type: FUNC 1276 * @tc.level Level 1 1277 * @tc.require: issueIAKC3I 1278 */ 1279 HWTEST_F(ServiceTest, SUB_Service_SessionDeactive_0000, TestSize.Level1) 1280 { 1281 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SessionDeactive_0000"; 1282 try { 1283 auto session_ = service->session_; 1284 service->session_ = nullptr; 1285 service->SessionDeactive(); 1286 service->session_ = session_; 1287 EXPECT_TRUE(true); 1288 1289 auto sched = service->sched_; 1290 service->sched_ = nullptr; 1291 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1292 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1293 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1294 service->SessionDeactive(); 1295 EXPECT_TRUE(true); 1296 1297 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) 1298 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1299 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1300 EXPECT_CALL(*session, CleanAndCheckIfNeedWait(_, _)).WillOnce(Return(false)); 1301 service->SessionDeactive(); 1302 EXPECT_TRUE(true); 1303 1304 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1305 EXPECT_CALL(*session, CleanAndCheckIfNeedWait(_, _)) 1306 .WillOnce(DoAll(SetArgReferee<0>(BError(BError::Codes::SA_INVAL_ARG)), Return(true))); 1307 service->SessionDeactive(); 1308 EXPECT_TRUE(true); 1309 1310 vector<string> bundleNameList {"bundleName"}; 1311 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); 1312 EXPECT_CALL(*session, CleanAndCheckIfNeedWait(_, _)) 1313 .WillOnce(DoAll(SetArgReferee<1>(bundleNameList), Return(true))); 1314 EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); 1315 service->SessionDeactive(); 1316 service->sched_ = sched; 1317 EXPECT_TRUE(true); 1318 } catch (...) { 1319 EXPECT_TRUE(false); 1320 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SessionDeactive."; 1321 } 1322 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SessionDeactive_0000"; 1323 } 1324 1325 /** 1326 * @tc.number: SUB_Service_SessionDeactive_0100 1327 * @tc.name: SUB_Service_SessionDeactive_0100 1328 * @tc.desc: 测试 SessionDeactive 的正常/异常分支 1329 * @tc.size: MEDIUM 1330 * @tc.type: FUNC 1331 * @tc.level Level 1 1332 * @tc.require: issueIAKC3I 1333 */ 1334 HWTEST_F(ServiceTest, SUB_Service_SessionDeactive_0100, TestSize.Level1) 1335 { 1336 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SessionDeactive_0100"; 1337 try { 1338 service->failedBundles_.clear(); 1339 service->successBundlesNum_ = 0; 1340 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1341 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1342 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1343 EXPECT_CALL(*session, ClearSessionData()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); 1344 EXPECT_CALL(*session, GetSessionCnt()).WillOnce(Return(0)); 1345 service->SessionDeactive(); 1346 EXPECT_TRUE(true); 1347 1348 service->isRmConfigFile_ = true; 1349 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1350 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1351 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1352 EXPECT_CALL(*session, ClearSessionData()).WillOnce(Return(BError(BError::Codes::OK))); 1353 EXPECT_CALL(*cdConfig, DeleteConfigFile()).WillOnce(Return(false)); 1354 EXPECT_CALL(*session, GetSessionCnt()).WillOnce(Return(0)); 1355 service->SessionDeactive(); 1356 EXPECT_TRUE(true); 1357 1358 service->isRmConfigFile_ = false; 1359 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1360 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1361 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1362 EXPECT_CALL(*session, ClearSessionData()).WillOnce(Return(BError(BError::Codes::OK))); 1363 EXPECT_CALL(*session, GetSessionCnt()).WillOnce(Return(0)); 1364 service->SessionDeactive(); 1365 EXPECT_TRUE(true); 1366 } catch (...) { 1367 EXPECT_TRUE(false); 1368 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SessionDeactive."; 1369 } 1370 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SessionDeactive_0100"; 1371 } 1372 1373 /** 1374 * @tc.number: SUB_Service_SessionDeactive_0200 1375 * @tc.name: SUB_Service_SessionDeactive_0200 1376 * @tc.desc: 测试 SessionDeactive 的正常/异常分支 1377 * @tc.size: MEDIUM 1378 * @tc.type: FUNC 1379 * @tc.level Level 1 1380 * @tc.require: issueIAKC3I 1381 */ 1382 HWTEST_F(ServiceTest, SUB_Service_SessionDeactive_0200, TestSize.Level1) 1383 { 1384 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SessionDeactive_0200"; 1385 try { 1386 service->failedBundles_.clear(); 1387 service->successBundlesNum_ = 0; 1388 service->isRmConfigFile_ = false; 1389 auto clearRecorder = service->clearRecorder_; 1390 service->clearRecorder_ = nullptr; 1391 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1392 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1393 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1394 EXPECT_CALL(*session, ClearSessionData()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); 1395 EXPECT_CALL(*session, GetSessionCnt()).WillOnce(Return(0)); 1396 service->SessionDeactive(); 1397 EXPECT_TRUE(true); 1398 1399 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1400 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) 1401 .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1402 EXPECT_CALL(*session, ClearSessionData()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); 1403 EXPECT_CALL(*session, GetSessionCnt()).WillOnce(Return(-1)); 1404 service->SessionDeactive(); 1405 service->clearRecorder_ = clearRecorder; 1406 EXPECT_TRUE(true); 1407 } catch (...) { 1408 EXPECT_TRUE(false); 1409 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SessionDeactive."; 1410 } 1411 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SessionDeactive_0200"; 1412 } 1413 1414 /** 1415 * @tc.number: SUB_Service_StartExtTimer_0000 1416 * @tc.name: SUB_Service_StartExtTimer_0000 1417 * @tc.desc: 测试 StartExtTimer 的正常/异常分支 1418 * @tc.size: MEDIUM 1419 * @tc.type: FUNC 1420 * @tc.level Level 1 1421 * @tc.require: issueIAKC3I 1422 */ 1423 HWTEST_F(ServiceTest, SUB_Service_StartExtTimer_0000, TestSize.Level1) 1424 { 1425 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_StartExtTimer_0000"; 1426 try { 1427 bool isExtStart = false; 1428 auto session_ = service->session_; 1429 service->session_ = nullptr; 1430 auto ret = service->StartExtTimer(isExtStart); 1431 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); 1432 1433 service->session_ = session_; 1434 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); 1435 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); 1436 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); 1437 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); 1438 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); 1439 EXPECT_CALL(*session, StartExtTimer(_, _)).WillOnce(Return(true)); 1440 ret = service->StartExtTimer(isExtStart); 1441 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 1442 } catch (...) { 1443 EXPECT_TRUE(false); 1444 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by StartExtTimer."; 1445 } 1446 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_StartExtTimer_0000"; 1447 } 1448 1449 /** 1450 * @tc.number: SUB_Service_StartFwkTimer_0000 1451 * @tc.name: SUB_Service_StartFwkTimer_0000 1452 * @tc.desc: 测试 StartFwkTimer 的正常/异常分支 1453 * @tc.size: MEDIUM 1454 * @tc.type: FUNC 1455 * @tc.level Level 1 1456 * @tc.require: issueIAKC3I 1457 */ 1458 HWTEST_F(ServiceTest, SUB_Service_StartFwkTimer_0000, TestSize.Level1) 1459 { 1460 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_StartFwkTimer_0000"; 1461 try { 1462 bool isFwkStart = false; 1463 auto session_ = service->session_; 1464 service->session_ = nullptr; 1465 auto ret = service->StartFwkTimer(isFwkStart); 1466 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); 1467 1468 service->session_ = session_; 1469 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); 1470 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); 1471 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); 1472 EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); 1473 EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); 1474 EXPECT_CALL(*session, StartFwkTimer(_, _)).WillOnce(Return(true)); 1475 ret = service->StartFwkTimer(isFwkStart); 1476 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); 1477 } catch (...) { 1478 EXPECT_TRUE(false); 1479 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by StartFwkTimer."; 1480 } 1481 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_StartFwkTimer_0000"; 1482 } 1483 1484 /** 1485 * @tc.number: SUB_Service_TimeoutRadarReport_0000 1486 * @tc.name: SUB_Service_TimeoutRadarReport_0000 1487 * @tc.desc: 测试 TimeoutRadarReport 的正常/异常分支 1488 * @tc.size: MEDIUM 1489 * @tc.type: FUNC 1490 * @tc.level Level 1 1491 * @tc.require: issueIAKC3I 1492 */ 1493 HWTEST_F(ServiceTest, SUB_Service_TimeoutRadarReport_0000, TestSize.Level1) 1494 { 1495 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_TimeoutRadarReport_0000"; 1496 try { 1497 string bundleName; 1498 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1499 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1500 service->TimeoutRadarReport(IServiceReverse::Scenario::BACKUP, bundleName); 1501 EXPECT_TRUE(true); 1502 1503 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1504 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1505 service->TimeoutRadarReport(IServiceReverse::Scenario::RESTORE, bundleName); 1506 EXPECT_TRUE(true); 1507 1508 service->TimeoutRadarReport(IServiceReverse::Scenario::UNDEFINED, bundleName); 1509 EXPECT_TRUE(true); 1510 } catch (...) { 1511 EXPECT_TRUE(false); 1512 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by TimeoutRadarReport."; 1513 } 1514 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_TimeoutRadarReport_0000"; 1515 } 1516 1517 /** 1518 * @tc.number: SUB_Service_GetLocalCapabilitiesForBundleInfos_0000 1519 * @tc.name: SUB_Service_GetLocalCapabilitiesForBundleInfos_0000 1520 * @tc.desc: 测试 GetLocalCapabilitiesForBundleInfos 的正常/异常分支 1521 * @tc.size: MEDIUM 1522 * @tc.type: FUNC 1523 * @tc.level Level 1 1524 * @tc.require: issueIAKC3I 1525 */ 1526 HWTEST_F(ServiceTest, SUB_Service_GetLocalCapabilitiesForBundleInfos_0000, TestSize.Level1) 1527 { 1528 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetLocalCapabilitiesForBundleInfos_0000"; 1529 try { 1530 ASSERT_TRUE(service != nullptr); 1531 auto session_ = service->session_; 1532 service->session_ = nullptr; 1533 EXPECT_EQ(-EPERM, service->GetLocalCapabilitiesForBundleInfos()); 1534 1535 service->session_ = session_; 1536 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); 1537 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); 1538 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); 1539 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1540 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1541 EXPECT_EQ(-EPERM, service->GetLocalCapabilitiesForBundleInfos()); 1542 } catch (...) { 1543 EXPECT_TRUE(false); 1544 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetLocalCapabilitiesForBundleInfos."; 1545 } 1546 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetLocalCapabilitiesForBundleInfos_0000"; 1547 } 1548 1549 /** 1550 * @tc.number: SUB_Service_GetBackupDataSize_0000 1551 * @tc.name: SUB_Service_GetBackupDataSize_0000 1552 * @tc.desc: 测试 GetBackupDataSize 接口 1553 * @tc.size: MEDIUM 1554 * @tc.type: FUNC 1555 * @tc.level Level 1 1556 * @tc.require: issueIAKC3I 1557 */ 1558 HWTEST_F(ServiceTest, SUB_Service_GetBackupDataSize_0000, TestSize.Level1) 1559 { 1560 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetBackupDataSize_0000"; 1561 try { 1562 bool isPreciseScan = true; 1563 vector<BIncrementalData> bundleNameList; 1564 BIncrementalData data; 1565 data.bundleName = BUNDLE_NAME; 1566 data.lastIncrementalTime = 0; 1567 bundleNameList.push_back(data); 1568 auto session_ = service->session_; 1569 service->session_ = nullptr; 1570 auto ret = service->GetBackupDataSize(isPreciseScan, bundleNameList); 1571 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); 1572 1573 service->session_ = session_; 1574 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); 1575 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE)); 1576 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); 1577 EXPECT_CALL(*token, VerifyAccessToken(_, _)) 1578 .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_DENIED)); 1579 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1580 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1581 ret = service->GetBackupDataSize(isPreciseScan, bundleNameList); 1582 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); 1583 1584 EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); 1585 EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); 1586 EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); 1587 EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); 1588 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1589 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1590 ret = service->GetBackupDataSize(isPreciseScan, bundleNameList); 1591 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); 1592 } catch (...) { 1593 EXPECT_TRUE(false); 1594 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetBackupDataSize."; 1595 } 1596 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetBackupDataSize_0000"; 1597 } 1598 1599 /** 1600 * @tc.number: SUB_Service_GetScanningInfo_0000 1601 * @tc.name: SUB_Service_GetScanningInfo_0000 1602 * @tc.desc: 测试 GetScanningInfo 接口 1603 * @tc.size: MEDIUM 1604 * @tc.type: FUNC 1605 * @tc.level Level 1 1606 * @tc.require: issueIAKC3I 1607 */ 1608 HWTEST_F(ServiceTest, SUB_Service_GetScanningInfo_0000, TestSize.Level1) 1609 { 1610 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetScanningInfo_0000"; 1611 try { 1612 size_t size = 1; 1613 string scanning = BUNDLE_NAME; 1614 EXPECT_FALSE(service->GetScanningInfo(nullptr, size, scanning)); 1615 1616 EXPECT_CALL(*jsonUtil, WriteToStr(_, _, _, _)).WillOnce(Return(false)); 1617 EXPECT_FALSE(service->GetScanningInfo(service, size, scanning)); 1618 1619 EXPECT_CALL(*jsonUtil, WriteToStr(_, _, _, _)).WillOnce(Return(true)); 1620 EXPECT_TRUE(service->GetScanningInfo(service, size, scanning)); 1621 } catch (...) { 1622 EXPECT_TRUE(false); 1623 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetScanningInfo."; 1624 } 1625 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetScanningInfo_0000"; 1626 } 1627 1628 /** 1629 * @tc.number: SUB_Service_WriteToList_0000 1630 * @tc.name: SUB_Service_WriteToList_0000 1631 * @tc.desc: 测试 WriteToList 接口 1632 * @tc.size: MEDIUM 1633 * @tc.type: FUNC 1634 * @tc.level Level 1 1635 * @tc.require: issueIAKC3I 1636 */ 1637 HWTEST_F(ServiceTest, SUB_Service_WriteToList_0000, TestSize.Level1) 1638 { 1639 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_WriteToList_0000"; 1640 try { 1641 ASSERT_TRUE(service != nullptr); 1642 BJsonUtil::BundleDataSize bundleDataSize; 1643 bundleDataSize.bundleName = BUNDLE_NAME; 1644 bundleDataSize.dataSize = 1; 1645 bundleDataSize.incDataSize = 1; 1646 service->WriteToList(bundleDataSize); 1647 ASSERT_TRUE(service->bundleDataSizeList_.back().bundleName == bundleDataSize.bundleName); 1648 service->bundleDataSizeList_.clear(); 1649 } catch (...) { 1650 EXPECT_TRUE(false); 1651 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by WriteToList."; 1652 } 1653 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_WriteToList_0000"; 1654 } 1655 1656 /** 1657 * @tc.number: SUB_Service_DeleteFromList_0000 1658 * @tc.name: SUB_Service_DeleteFromList_0000 1659 * @tc.desc: 测试 DeleteFromList 接口 1660 * @tc.size: MEDIUM 1661 * @tc.type: FUNC 1662 * @tc.level Level 1 1663 * @tc.require: issueIAKC3I 1664 */ 1665 HWTEST_F(ServiceTest, SUB_Service_DeleteFromList_0000, TestSize.Level1) 1666 { 1667 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_DeleteFromList_0000"; 1668 try { 1669 ASSERT_TRUE(service != nullptr); 1670 auto ret = service->bundleDataSizeList_.size(); 1671 BJsonUtil::BundleDataSize bundleDataSize; 1672 bundleDataSize.bundleName = BUNDLE_NAME; 1673 bundleDataSize.dataSize = 1; 1674 bundleDataSize.incDataSize = 1; 1675 service->bundleDataSizeList_.push_back(bundleDataSize); 1676 service->DeleteFromList(1); 1677 EXPECT_EQ(service->bundleDataSizeList_.size(), ret); 1678 service->bundleDataSizeList_.clear(); 1679 } catch (...) { 1680 EXPECT_TRUE(false); 1681 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by DeleteFromList."; 1682 } 1683 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_DeleteFromList_0000"; 1684 } 1685 1686 /** 1687 * @tc.number: SUB_Service_SetScanningInfo_0000 1688 * @tc.name: SUB_Service_SetScanningInfo_0000 1689 * @tc.desc: 测试 SetScanningInfo 接口 1690 * @tc.size: MEDIUM 1691 * @tc.type: FUNC 1692 * @tc.level Level 1 1693 * @tc.require: issueIAKC3I 1694 */ 1695 HWTEST_F(ServiceTest, SUB_Service_SetScanningInfo_0000, TestSize.Level1) 1696 { 1697 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SetScanningInfo_0000"; 1698 try { 1699 ASSERT_TRUE(service != nullptr); 1700 string scanning = ""; 1701 string name = BUNDLE_NAME; 1702 service->SetScanningInfo(scanning, name); 1703 EXPECT_EQ(scanning, name); 1704 } catch (...) { 1705 EXPECT_TRUE(false); 1706 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SetScanningInfo."; 1707 } 1708 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SetScanningInfo_0000"; 1709 } 1710 1711 /** 1712 * @tc.number: SUB_Service_WriteScannedInfoToList_0000 1713 * @tc.name: SUB_Service_WriteScannedInfoToList_0000 1714 * @tc.desc: 测试 WriteScannedInfoToList 接口 1715 * @tc.size: MEDIUM 1716 * @tc.type: FUNC 1717 * @tc.level Level 1 1718 * @tc.require: issueIAKC3I 1719 */ 1720 HWTEST_F(ServiceTest, SUB_Service_WriteScannedInfoToList_0000, TestSize.Level1) 1721 { 1722 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_WriteScannedInfoToList_0000"; 1723 try { 1724 ASSERT_TRUE(service != nullptr); 1725 auto ret = service->bundleDataSizeList_.size(); 1726 string bundleName = BUNDLE_NAME; 1727 int64_t dataSize = 1; 1728 int64_t incDataSize = 1; 1729 service->WriteScannedInfoToList(bundleName, dataSize, incDataSize); 1730 EXPECT_EQ(service->bundleDataSizeList_.size(), ret + 1); 1731 service->bundleDataSizeList_.clear(); 1732 } catch (...) { 1733 EXPECT_TRUE(false); 1734 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by WriteScannedInfoToList."; 1735 } 1736 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_WriteScannedInfoToList_0000"; 1737 } 1738 1739 /** 1740 * @tc.number: SUB_Service_GetPrecisesSize_0000 1741 * @tc.name: SUB_Service_GetPrecisesSize_0000 1742 * @tc.desc: 测试 GetPrecisesSize 接口 1743 * @tc.size: MEDIUM 1744 * @tc.type: FUNC 1745 * @tc.level Level 1 1746 * @tc.require: issueIAKC3I 1747 */ 1748 HWTEST_F(ServiceTest, SUB_Service_GetPrecisesSize_0000, TestSize.Level1) 1749 { 1750 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetPrecisesSize_0000"; 1751 try { 1752 vector<BIncrementalData> bundleNameList; 1753 BIncrementalData data; 1754 data.bundleName = BUNDLE_NAME; 1755 data.lastIncrementalTime = 0; 1756 bundleNameList.push_back(data); 1757 string scanning = ""; 1758 BJsonUtil::BundleDetailInfo info; 1759 info.bundleIndex = 1; 1760 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); 1761 EXPECT_CALL(*sms, GetBundleStatsForIncrease(_, _, _, _, _)).WillOnce(Return(0)); 1762 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1763 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1764 service->GetPrecisesSize(bundleNameList, scanning); 1765 EXPECT_EQ(service->bundleDataSizeList_.size(), 0); 1766 service->bundleDataSizeList_.clear(); 1767 1768 vector<BIncrementalData> bundleNameListTwo; 1769 BIncrementalData dataTwo; 1770 dataTwo.bundleName = BUNDLE_NAME; 1771 dataTwo.lastIncrementalTime = 1; 1772 bundleNameListTwo.push_back(dataTwo); 1773 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); 1774 EXPECT_CALL(*sms, GetBundleStatsForIncrease(_, _, _, _, _)).WillOnce(Return(0)); 1775 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1776 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1777 service->GetPrecisesSize(bundleNameListTwo, scanning); 1778 EXPECT_EQ(service->bundleDataSizeList_.size(), 0); 1779 service->bundleDataSizeList_.clear(); 1780 1781 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); 1782 EXPECT_CALL(*sms, GetBundleStatsForIncrease(_, _, _, _, _)).WillOnce(Return(1)); 1783 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1784 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1785 service->GetPrecisesSize(bundleNameListTwo, scanning); 1786 EXPECT_EQ(service->bundleDataSizeList_.size(), 1); 1787 service->bundleDataSizeList_.clear(); 1788 } catch (...) { 1789 EXPECT_TRUE(false); 1790 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetPrecisesSize."; 1791 } 1792 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetPrecisesSize_0000"; 1793 } 1794 1795 /** 1796 * @tc.number: SUB_Service_GetPrecisesSize_0100 1797 * @tc.name: SUB_Service_GetPrecisesSize_0100 1798 * @tc.desc: 测试 GetPrecisesSize 接口 1799 * @tc.size: MEDIUM 1800 * @tc.type: FUNC 1801 * @tc.level Level 1 1802 * @tc.require: issueIAKC3I 1803 */ 1804 HWTEST_F(ServiceTest, SUB_Service_GetPrecisesSize_0100, TestSize.Level1) 1805 { 1806 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetPrecisesSize_0100"; 1807 try { 1808 string scanning = ""; 1809 BJsonUtil::BundleDetailInfo info; 1810 info.bundleIndex = 0; 1811 vector<BIncrementalData> bundleNameListTwo; 1812 BIncrementalData dataTwo; 1813 dataTwo.bundleName = BUNDLE_NAME; 1814 dataTwo.lastIncrementalTime = 1; 1815 bundleNameListTwo.push_back(dataTwo); 1816 EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)) 1817 .WillOnce(Return(info)).WillOnce(Return(info)); 1818 EXPECT_CALL(*sms, GetBundleStatsForIncrease(_, _, _, _, _)).WillOnce(Return(0)) 1819 .WillOnce(Return(0)).WillOnce(Return(0)); 1820 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1821 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))) 1822 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))) 1823 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1824 service->GetPrecisesSize(bundleNameListTwo, scanning); 1825 EXPECT_EQ(service->bundleDataSizeList_.size(), 0); 1826 service->bundleDataSizeList_.clear(); 1827 } catch (...) { 1828 EXPECT_TRUE(false); 1829 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetPrecisesSize."; 1830 } 1831 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetPrecisesSize_0100"; 1832 } 1833 1834 /** 1835 * @tc.number: SUB_Service_GetPresumablySize_0000 1836 * @tc.name: SUB_Service_GetPresumablySize_0000 1837 * @tc.desc: 测试 GetPresumablySize 接口 1838 * @tc.size: MEDIUM 1839 * @tc.type: FUNC 1840 * @tc.level Level 1 1841 * @tc.require: issueIAKC3I 1842 */ 1843 HWTEST_F(ServiceTest, SUB_Service_GetPresumablySize_0000, TestSize.Level1) 1844 { 1845 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetPresumablySize_0000"; 1846 try { 1847 auto ret = service->bundleDataSizeList_.size(); 1848 vector<BIncrementalData> bundleNameList; 1849 BIncrementalData data; 1850 data.bundleName = BUNDLE_NAME; 1851 data.lastIncrementalTime = 0; 1852 bundleNameList.push_back(data); 1853 string scanning = ""; 1854 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); 1855 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1856 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1857 service->GetPresumablySize(bundleNameList, scanning); 1858 EXPECT_EQ(service->bundleDataSizeList_.size(), ret + 1); 1859 service->bundleDataSizeList_.clear(); 1860 1861 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 1862 EXPECT_CALL(*bms, GetBundleDataSize(_, _)).WillOnce(Return(0)); 1863 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1864 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1865 service->GetPresumablySize(bundleNameList, scanning); 1866 EXPECT_EQ(service->bundleDataSizeList_.size(), 1); 1867 service->bundleDataSizeList_.clear(); 1868 1869 EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); 1870 EXPECT_CALL(*bms, GetBundleDataSize(_, _)).WillOnce(Return(1)); 1871 EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) 1872 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))) 1873 .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1))); 1874 service->GetPresumablySize(bundleNameList, scanning); 1875 EXPECT_EQ(service->bundleDataSizeList_.size(), 1); 1876 service->bundleDataSizeList_.clear(); 1877 } catch (...) { 1878 EXPECT_TRUE(false); 1879 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetPresumablySize."; 1880 } 1881 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetPresumablySize_0000"; 1882 } 1883 1884 /** 1885 * @tc.number: SUB_Service_GetDataSizeStepByStep_0000 1886 * @tc.name: SUB_Service_GetDataSizeStepByStep_0000 1887 * @tc.desc: 测试 GetDataSizeStepByStep 接口 1888 * @tc.size: MEDIUM 1889 * @tc.type: FUNC 1890 * @tc.level Level 1 1891 * @tc.require: issueIAKC3I 1892 */ 1893 HWTEST_F(ServiceTest, SUB_Service_GetDataSizeStepByStep_0000, TestSize.Level1) 1894 { 1895 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetDataSizeStepByStep_0000"; 1896 try { 1897 bool isPreciseScan = false; 1898 vector<BIncrementalData> bundleNameList; 1899 string scanning = ""; __anonb1b9b2900102(const ThreadPool::Task &f) 1900 EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { 1901 f(); 1902 }))); 1903 service->GetDataSizeStepByStep(isPreciseScan, bundleNameList, scanning); 1904 EXPECT_TRUE(true); 1905 1906 isPreciseScan = true; __anonb1b9b2900202(const ThreadPool::Task &f) 1907 EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { 1908 f(); 1909 }))); 1910 service->GetDataSizeStepByStep(isPreciseScan, bundleNameList, scanning); 1911 EXPECT_TRUE(true); 1912 } catch (...) { 1913 EXPECT_TRUE(false); 1914 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetDataSizeStepByStep."; 1915 } 1916 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetDataSizeStepByStep_0000"; 1917 } 1918 1919 /** 1920 * @tc.number: SUB_Service_CyclicSendScannedInfo_0000 1921 * @tc.name: SUB_Service_CyclicSendScannedInfo_0000 1922 * @tc.desc: 测试 CyclicSendScannedInfo 接口 1923 * @tc.size: MEDIUM 1924 * @tc.type: FUNC 1925 * @tc.level Level 1 1926 * @tc.require: issueIAKC3I 1927 */ 1928 HWTEST_F(ServiceTest, SUB_Service_CyclicSendScannedInfo_0000, TestSize.Level1) 1929 { 1930 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_CyclicSendScannedInfo_0000"; 1931 try { 1932 bool isPreciseScan = false; 1933 vector<BIncrementalData> bundleNameList; __anonb1b9b2900302(const ThreadPool::Task &f) 1934 EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { 1935 f(); 1936 }))).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { 1937 service->isScannedEnd_.store(true); 1938 }))); 1939 service->CyclicSendScannedInfo(isPreciseScan, bundleNameList); 1940 EXPECT_TRUE(true); 1941 1942 isPreciseScan = true; __anonb1b9b2900502(const ThreadPool::Task &f) 1943 EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { 1944 f(); 1945 }))).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { 1946 service->isScannedEnd_.store(true); 1947 }))); 1948 service->CyclicSendScannedInfo(isPreciseScan, bundleNameList); 1949 EXPECT_TRUE(true); 1950 } catch (...) { 1951 EXPECT_TRUE(false); 1952 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CyclicSendScannedInfo."; 1953 } 1954 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_CyclicSendScannedInfo_0000"; 1955 } 1956 1957 /** 1958 * @tc.number: SUB_Service_SendScannedInfo_0000 1959 * @tc.name: SUB_Service_SendScannedInfo_0000 1960 * @tc.desc: 测试 SendScannedInfo 接口 1961 * @tc.size: MEDIUM 1962 * @tc.type: FUNC 1963 * @tc.level Level 1 1964 * @tc.require: issueIAKC3I 1965 */ 1966 HWTEST_F(ServiceTest, SUB_Service_SendScannedInfo_0000, TestSize.Level1) 1967 { 1968 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendScannedInfo_0000"; 1969 try { 1970 string scannendInfos = ""; 1971 service->SendScannedInfo(scannendInfos, nullptr); 1972 EXPECT_TRUE(true); 1973 1974 auto session_ = service->session_; 1975 EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); 1976 EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); 1977 EXPECT_CALL(*srProxy, BackupOnScanningInfo(_)).WillOnce(Return()); __anonb1b9b2900702(const ThreadPool::Task &f) 1978 EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { 1979 f(); 1980 }))); 1981 service->SendScannedInfo(scannendInfos, session_); 1982 EXPECT_TRUE(true); 1983 } catch (...) { 1984 EXPECT_TRUE(false); 1985 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CyclicSendScannedInfo."; 1986 } 1987 GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SendScannedInfo_0000"; 1988 }