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