1 /* 2 * Copyright (c) 2022-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 #include <cstdio> 17 #include <fcntl.h> 18 #include <gmock/gmock.h> 19 #include <gtest/gtest.h> 20 #include <message_parcel.h> 21 #include <string_ex.h> 22 #include <sys/stat.h> 23 #include <sys/types.h> 24 25 #include "b_error/b_error.h" 26 #include "i_service_reverse.h" 27 #include "service_reverse_stub.h" 28 #include "test_manager.h" 29 #include "unique_fd.h" 30 31 namespace OHOS::FileManagement::Backup { 32 using namespace std; 33 using namespace testing; 34 35 namespace { 36 const string BUNDLE_NAME = "com.example.app2backup"; 37 const string FILE_NAME = "1.tar"; 38 const string FILE_NAME_MANIFEST = "1.fr"; 39 } // namespace 40 41 class MockServiceReverse final : public ServiceReverseStub { 42 public: 43 MOCK_METHOD4(BackupOnFileReady, void(string bundleName, string fileName, int fd, int32_t errCode)); 44 MOCK_METHOD2(BackupOnBundleStarted, void(int32_t errCode, string bundleName)); 45 MOCK_METHOD2(BackupOnResultReport, void(string result, std::string bundleName)); 46 MOCK_METHOD2(BackupOnBundleFinished, void(int32_t errCode, string bundleName)); 47 MOCK_METHOD1(BackupOnAllBundlesFinished, void(int32_t errCode)); 48 MOCK_METHOD2(BackupOnProcessInfo, void(std::string bundleName, std::string processInfo)); 49 MOCK_METHOD1(BackupOnScanningInfo, void(std::string scannedInfo)); 50 51 MOCK_METHOD2(RestoreOnBundleStarted, void(int32_t errCode, std::string bundleName)); 52 MOCK_METHOD2(RestoreOnBundleFinished, void(int32_t errCode, string bundleName)); 53 MOCK_METHOD1(RestoreOnAllBundlesFinished, void(int32_t errCode)); 54 MOCK_METHOD4(RestoreOnFileReady, void(string bundleName, string fileName, int fd, int32_t errCode)); 55 MOCK_METHOD3(RestoreOnResultReport, void(string result, string bundleName, ErrCode errCode)); 56 MOCK_METHOD2(RestoreOnProcessInfo, void(std::string bundleName, std::string processInfo)); 57 58 MOCK_METHOD5(IncrementalBackupOnFileReady, 59 void(string bundleName, string fileName, int fd, int manifestFd, int32_t errCode)); 60 MOCK_METHOD2(IncrementalBackupOnBundleStarted, void(int32_t errCode, string bundleName)); 61 MOCK_METHOD2(IncrementalBackupOnResultReport, void(string result, std::string bundleName)); 62 MOCK_METHOD2(IncrementalBackupOnBundleFinished, void(int32_t errCode, string bundleName)); 63 MOCK_METHOD1(IncrementalBackupOnAllBundlesFinished, void(int32_t errCode)); 64 MOCK_METHOD2(IncrementalBackupOnProcessInfo, void(std::string bundleName, std::string processInfo)); 65 MOCK_METHOD1(IncrementalBackupOnScanningInfo, void(std::string scannedInfo)); 66 67 MOCK_METHOD2(IncrementalRestoreOnBundleStarted, void(int32_t errCode, std::string bundleName)); 68 MOCK_METHOD2(IncrementalRestoreOnBundleFinished, void(int32_t errCode, string bundleName)); 69 MOCK_METHOD1(IncrementalRestoreOnAllBundlesFinished, void(int32_t errCode)); 70 MOCK_METHOD5(IncrementalRestoreOnFileReady, 71 void(string bundleName, string fileName, int fd, int manifestFd, int32_t errCode)); 72 MOCK_METHOD3(IncrementalRestoreOnResultReport, void(string result, string bundleName, ErrCode errCode)); 73 MOCK_METHOD2(IncrementalRestoreOnProcessInfo, void(std::string bundleName, std::string processInfo)); 74 }; 75 76 class ServiceReverseStubTest : public testing::Test { 77 public: SetUpTestCase(void)78 static void SetUpTestCase(void) {}; TearDownTestCase()79 static void TearDownTestCase() {}; SetUp()80 void SetUp() override {}; TearDown()81 void TearDown() override {}; 82 }; 83 84 /** 85 * @tc.number: SUB_backup_ServiceReverseStub_BackupOnFileReady_0100 86 * @tc.name: SUB_backup_ServiceReverseStub_BackupOnFileReady_0100 87 * @tc.desc: Test function of BackupOnFileReady interface for SUCCESS. 88 * @tc.size: MEDIUM 89 * @tc.type: FUNC 90 * @tc.level Level 1 91 * @tc.require: I6F3GV 92 */ 93 HWTEST_F(ServiceReverseStubTest, SUB_backup_ServiceReverseStub_BackupOnFileReady_0100, testing::ext::TestSize.Level1) 94 { 95 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnFileReady_0100"; 96 try { 97 MockServiceReverse service; 98 EXPECT_CALL(service, BackupOnFileReady(_, _, _, _)).WillOnce(Return()); 99 MessageParcel data; 100 MessageParcel reply; 101 MessageOption option; 102 103 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 104 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 105 EXPECT_TRUE(data.WriteString(FILE_NAME)); 106 TestManager tm("ServiceReverseStub_0100"); 107 string filePath = tm.GetRootDirCurTest().append(FILE_NAME); 108 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); 109 data.WriteFileDescriptor(fd); 110 data.WriteInt32(0); 111 112 EXPECT_EQ( 113 BError(BError::Codes::OK), 114 service.OnRemoteRequest(static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_FILE_READY), 115 data, reply, option)); 116 } catch (...) { 117 EXPECT_TRUE(false); 118 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnFileReady."; 119 } 120 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnFileReady_0100"; 121 } 122 123 /** 124 * @tc.number: SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100 125 * @tc.name: SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100 126 * @tc.desc: Test function of BackupOnBundleStarted interface for SUCCESS. 127 * @tc.size: MEDIUM 128 * @tc.type: FUNC 129 * @tc.level Level 1 130 * @tc.require: I6F3GV 131 */ 132 HWTEST_F(ServiceReverseStubTest, 133 SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100, 134 testing::ext::TestSize.Level1) 135 { 136 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100"; 137 try { 138 MockServiceReverse service; 139 EXPECT_CALL(service, BackupOnBundleStarted(_, _)).WillOnce(Return()); 140 MessageParcel data; 141 MessageParcel reply; 142 MessageOption option; 143 144 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 145 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 146 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 147 148 EXPECT_EQ(BError(BError::Codes::OK), 149 service.OnRemoteRequest( 150 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_STARTED), data, 151 reply, option)); 152 } catch (...) { 153 EXPECT_TRUE(false); 154 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnBundleStarted."; 155 } 156 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100"; 157 } 158 159 /** 160 * @tc.number: SUB_backup_ServiceReverseStub_BackupOnResultReport_0100 161 * @tc.name: SUB_backup_ServiceReverseStub_BackupOnResultReport_0100 162 * @tc.desc: Test function of BackupOnResultReport interface for SUCCESS. 163 * @tc.size: MEDIUM 164 * @tc.type: FUNC 165 * @tc.level Level 1 166 * @tc.require: I6F3GV 167 */ 168 HWTEST_F(ServiceReverseStubTest, 169 SUB_backup_ServiceReverseStub_BackupOnResultReport_0100, 170 testing::ext::TestSize.Level1) 171 { 172 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnResultReport_0100"; 173 try { 174 MockServiceReverse service; 175 EXPECT_CALL(service, BackupOnResultReport(_, _)).WillOnce(Return()); 176 MessageParcel data; 177 MessageParcel reply; 178 MessageOption option; 179 180 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 181 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 182 183 EXPECT_EQ(BError(BError::Codes::OK), 184 service.OnRemoteRequest( 185 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_RESULT_REPORT), data, 186 reply, option)); 187 } catch (...) { 188 EXPECT_TRUE(false); 189 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnResultReport."; 190 } 191 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnResultReport_0100"; 192 } 193 194 /** 195 * @tc.number: SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100 196 * @tc.name: SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100 197 * @tc.desc: Test function of BackupOnBundleFinished interface for SUCCESS. 198 * @tc.size: MEDIUM 199 * @tc.type: FUNC 200 * @tc.level Level 1 201 * @tc.require: I6F3GV 202 */ 203 HWTEST_F(ServiceReverseStubTest, 204 SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100, 205 testing::ext::TestSize.Level1) 206 { 207 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100"; 208 try { 209 MockServiceReverse service; 210 EXPECT_CALL(service, BackupOnBundleFinished(_, _)).WillOnce(Return()); 211 MessageParcel data; 212 MessageParcel reply; 213 MessageOption option; 214 215 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 216 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 217 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 218 219 EXPECT_EQ(BError(BError::Codes::OK), 220 service.OnRemoteRequest( 221 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_FINISHED), data, 222 reply, option)); 223 } catch (...) { 224 EXPECT_TRUE(false); 225 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnBundleFinished."; 226 } 227 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100"; 228 } 229 230 /** 231 * @tc.number: SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100 232 * @tc.name: SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100 233 * @tc.desc: Test function of BackupOnAllBundlesFinished interface for SUCCESS. 234 * @tc.size: MEDIUM 235 * @tc.type: FUNC 236 * @tc.level Level 1 237 * @tc.require: I6F3GV 238 */ 239 HWTEST_F(ServiceReverseStubTest, 240 SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100, 241 testing::ext::TestSize.Level1) 242 { 243 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100"; 244 try { 245 MockServiceReverse service; 246 EXPECT_CALL(service, BackupOnAllBundlesFinished(_)).WillOnce(Return()); 247 MessageParcel data; 248 MessageParcel reply; 249 MessageOption option; 250 251 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 252 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 253 254 EXPECT_EQ(BError(BError::Codes::OK), 255 service.OnRemoteRequest( 256 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_TASK_FINISHED), data, 257 reply, option)); 258 } catch (...) { 259 EXPECT_TRUE(false); 260 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnAllBundlesFinished."; 261 } 262 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100"; 263 } 264 265 /** 266 * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100 267 * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100 268 * @tc.desc: Test function of RestoreOnBundleStarted interface for SUCCESS. 269 * @tc.size: MEDIUM 270 * @tc.type: FUNC 271 * @tc.level Level 1 272 * @tc.require: I6F3GV 273 */ 274 HWTEST_F(ServiceReverseStubTest, 275 SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100, 276 testing::ext::TestSize.Level1) 277 { 278 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100"; 279 try { 280 MockServiceReverse service; 281 EXPECT_CALL(service, RestoreOnBundleStarted(_, _)).WillOnce(Return()); 282 MessageParcel data; 283 MessageParcel reply; 284 MessageOption option; 285 286 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 287 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 288 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 289 290 EXPECT_EQ(BError(BError::Codes::OK), 291 service.OnRemoteRequest( 292 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_STARTED), data, 293 reply, option)); 294 } catch (...) { 295 EXPECT_TRUE(false); 296 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnBundleStarted."; 297 } 298 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100"; 299 } 300 301 /** 302 * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100 303 * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100 304 * @tc.desc: Test function of RestoreOnBundleFinished interface for SUCCESS. 305 * @tc.size: MEDIUM 306 * @tc.type: FUNC 307 * @tc.level Level 1 308 * @tc.require: I6F3GV 309 */ 310 HWTEST_F(ServiceReverseStubTest, 311 SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100, 312 testing::ext::TestSize.Level1) 313 { 314 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100"; 315 try { 316 MockServiceReverse service; 317 EXPECT_CALL(service, RestoreOnBundleFinished(_, _)).WillOnce(Return()); 318 MessageParcel data; 319 MessageParcel reply; 320 MessageOption option; 321 322 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 323 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 324 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 325 326 EXPECT_EQ(BError(BError::Codes::OK), 327 service.OnRemoteRequest( 328 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_FINISHED), data, 329 reply, option)); 330 } catch (...) { 331 EXPECT_TRUE(false); 332 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnBundleFinished."; 333 } 334 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100"; 335 } 336 337 /** 338 * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100 339 * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100 340 * @tc.desc: Test function of RestoreOnBundleStarted interface for SUCCESS. 341 * @tc.size: MEDIUM 342 * @tc.type: FUNC 343 * @tc.level Level 1 344 * @tc.require: I6F3GV 345 */ 346 HWTEST_F(ServiceReverseStubTest, 347 SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100, 348 testing::ext::TestSize.Level1) 349 { 350 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100"; 351 try { 352 MockServiceReverse service; 353 EXPECT_CALL(service, RestoreOnAllBundlesFinished(_)).WillOnce(Return()); 354 MessageParcel data; 355 MessageParcel reply; 356 MessageOption option; 357 358 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 359 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 360 361 EXPECT_EQ(BError(BError::Codes::OK), 362 service.OnRemoteRequest( 363 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_TASK_FINISHED), data, 364 reply, option)); 365 } catch (...) { 366 EXPECT_TRUE(false); 367 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnAllBundlesFinished."; 368 } 369 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100"; 370 } 371 372 /** 373 * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100 374 * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100 375 * @tc.desc: Test function of RestoreOnFileReady interface for SUCCESS. 376 * @tc.size: MEDIUM 377 * @tc.type: FUNC 378 * @tc.level Level 1 379 * @tc.require: I6F3GV 380 */ 381 HWTEST_F(ServiceReverseStubTest, SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100, testing::ext::TestSize.Level1) 382 { 383 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100"; 384 try { 385 MockServiceReverse service; 386 EXPECT_CALL(service, RestoreOnFileReady(_, _, _, _)).WillOnce(Return()); 387 MessageParcel data; 388 MessageParcel reply; 389 MessageOption option; 390 int32_t errCode = 0; 391 bool fdFlag = true; 392 393 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 394 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 395 EXPECT_TRUE(data.WriteString(FILE_NAME)); 396 397 TestManager tm("ServiceReverseStub_0200"); 398 string filePath = tm.GetRootDirCurTest().append(FILE_NAME); 399 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); 400 if (fd < 0) { 401 errCode = BError::GetCodeByErrno(errno); 402 fdFlag = false; 403 } 404 data.WriteBool(fdFlag); 405 if (fdFlag == true) { 406 data.WriteFileDescriptor(fd); 407 } 408 data.WriteInt32(errCode); 409 410 EXPECT_EQ( 411 BError(BError::Codes::OK), 412 service.OnRemoteRequest(static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_FILE_READY), 413 data, reply, option)); 414 } catch (...) { 415 EXPECT_TRUE(false); 416 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnFileReady."; 417 } 418 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100"; 419 } 420 421 /** 422 * @tc.number: SUB_backup_ServiceReverseStub_error_0100 423 * @tc.name: SUB_backup_ServiceReverseStub_error_0100 424 * @tc.desc: Test function of RestoreOnFileReady interface for SUCCESS. 425 * @tc.size: MEDIUM 426 * @tc.type: FUNC 427 * @tc.level Level 1 428 * @tc.require: I6F3GV 429 */ 430 HWTEST_F(ServiceReverseStubTest, SUB_backup_ServiceReverseStub_error_0100, testing::ext::TestSize.Level1) 431 { 432 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_error_0100"; 433 try { 434 MockServiceReverse service; 435 MessageParcel data; 436 MessageParcel reply; 437 MessageOption option; 438 EXPECT_TRUE(data.WriteInterfaceToken(Str8ToStr16("test"))); 439 440 EXPECT_NE(BError(BError::Codes::OK), service.OnRemoteRequest(3333, data, reply, option)); 441 EXPECT_NE( 442 BError(BError::Codes::OK), 443 service.OnRemoteRequest(static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_FILE_READY), 444 data, reply, option)); 445 } catch (...) { 446 EXPECT_TRUE(false); 447 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred."; 448 } 449 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_error_0100"; 450 } 451 452 /** 453 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnFileReady_0100 454 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnFileReady_0100 455 * @tc.desc: Test function of IncrementalBackupOnFileReady interface for SUCCESS. 456 * @tc.size: MEDIUM 457 * @tc.type: FUNC 458 * @tc.level Level 1 459 * @tc.require: I90ZZX 460 */ 461 HWTEST_F(ServiceReverseStubTest, 462 SUB_backup_ServiceReverseStub_IncrementalBackupOnFileReady_0100, 463 testing::ext::TestSize.Level1) 464 { 465 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnFileReady_0100"; 466 try { 467 MockServiceReverse service; 468 EXPECT_CALL(service, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); 469 MessageParcel data; 470 MessageParcel reply; 471 MessageOption option; 472 473 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 474 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 475 EXPECT_TRUE(data.WriteString(FILE_NAME)); 476 TestManager tm("ServiceReverseStub_0300"); 477 string filePath = tm.GetRootDirCurTest().append(FILE_NAME); 478 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); 479 data.WriteFileDescriptor(fd); 480 TestManager tm2("ServiceReverseStub_0301"); 481 string filePathManifest = tm2.GetRootDirCurTest().append(FILE_NAME_MANIFEST); 482 UniqueFd fdManifest(open(filePathManifest.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); 483 data.WriteFileDescriptor(fdManifest); 484 data.WriteInt32(0); 485 486 EXPECT_EQ(BError(BError::Codes::OK), 487 service.OnRemoteRequest( 488 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_FILE_READY), 489 data, reply, option)); 490 } catch (...) { 491 EXPECT_TRUE(false); 492 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalBackupOnFileReady."; 493 } 494 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnFileReady_0100"; 495 } 496 497 /** 498 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleStarted_0100 499 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleStarted_0100 500 * @tc.desc: Test function of IncrementalBackupOnBundleStarted interface for SUCCESS. 501 * @tc.size: MEDIUM 502 * @tc.type: FUNC 503 * @tc.level Level 1 504 * @tc.require: I90ZZX 505 */ 506 HWTEST_F(ServiceReverseStubTest, 507 SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleStarted_0100, 508 testing::ext::TestSize.Level1) 509 { 510 GTEST_LOG_(INFO) 511 << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleStarted_0100"; 512 try { 513 MockServiceReverse service; 514 EXPECT_CALL(service, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); 515 MessageParcel data; 516 MessageParcel reply; 517 MessageOption option; 518 519 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 520 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 521 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 522 523 EXPECT_EQ( 524 BError(BError::Codes::OK), 525 service.OnRemoteRequest( 526 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_STARTED), 527 data, reply, option)); 528 } catch (...) { 529 EXPECT_TRUE(false); 530 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalBackupOnBundleStarted."; 531 } 532 GTEST_LOG_(INFO) 533 << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleStarted_0100"; 534 } 535 536 /** 537 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnResultReport_0100 538 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnResultReport_0100 539 * @tc.desc: Test function of IncrementalBackupOnResultReport interface for SUCCESS. 540 * @tc.size: MEDIUM 541 * @tc.type: FUNC 542 * @tc.level Level 1 543 * @tc.require: I90ZZX 544 */ 545 HWTEST_F(ServiceReverseStubTest, 546 SUB_backup_ServiceReverseStub_IncrementalBackupOnResultReport_0100, 547 testing::ext::TestSize.Level1) 548 { 549 GTEST_LOG_(INFO) 550 << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnResultReport_0100"; 551 try { 552 MockServiceReverse service; 553 EXPECT_CALL(service, IncrementalBackupOnResultReport(_, _)).WillOnce(Return()); 554 MessageParcel data; 555 MessageParcel reply; 556 MessageOption option; 557 558 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 559 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 560 561 EXPECT_EQ( 562 BError(BError::Codes::OK), 563 service.OnRemoteRequest( 564 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_RESULT_REPORT), 565 data, reply, option)); 566 } catch (...) { 567 EXPECT_TRUE(false); 568 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalBackupOnResultReport."; 569 } 570 GTEST_LOG_(INFO) 571 << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnResultReport_0100"; 572 } 573 574 /** 575 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleFinished_0100 576 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleFinished_0100 577 * @tc.desc: Test function of IncrementalBackupOnBundleFinished interface for SUCCESS. 578 * @tc.size: MEDIUM 579 * @tc.type: FUNC 580 * @tc.level Level 1 581 * @tc.require: I90ZZX 582 */ 583 HWTEST_F(ServiceReverseStubTest, 584 SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleFinished_0100, 585 testing::ext::TestSize.Level1) 586 { 587 GTEST_LOG_(INFO) 588 << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleFinished_0100"; 589 try { 590 MockServiceReverse service; 591 EXPECT_CALL(service, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return()); 592 MessageParcel data; 593 MessageParcel reply; 594 MessageOption option; 595 596 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 597 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 598 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 599 600 EXPECT_EQ( 601 BError(BError::Codes::OK), 602 service.OnRemoteRequest( 603 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_FINISHED), 604 data, reply, option)); 605 } catch (...) { 606 EXPECT_TRUE(false); 607 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalBackupOnBundleFinished."; 608 } 609 GTEST_LOG_(INFO) 610 << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleFinished_0100"; 611 } 612 613 /** 614 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnAllBundlesFinished_0100 615 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnAllBundlesFinished_0100 616 * @tc.desc: Test function of IncrementalBackupOnAllBundlesFinished interface for SUCCESS. 617 * @tc.size: MEDIUM 618 * @tc.type: FUNC 619 * @tc.level Level 1 620 * @tc.require: I90ZZX 621 */ 622 623 HWTEST_F(ServiceReverseStubTest, 624 SUB_backup_ServiceReverseStub_IncrementalBackupOnAllBundlesFinished_0100, 625 testing::ext::TestSize.Level1) 626 { 627 GTEST_LOG_(INFO) 628 << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnAllBundlesFinished_0100"; 629 try { 630 MockServiceReverse service; 631 EXPECT_CALL(service, IncrementalBackupOnAllBundlesFinished(_)).WillOnce(Return()); 632 MessageParcel data; 633 MessageParcel reply; 634 MessageOption option; 635 636 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 637 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 638 639 EXPECT_EQ(BError(BError::Codes::OK), 640 service.OnRemoteRequest( 641 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_TASK_FINISHED), 642 data, reply, option)); 643 } catch (...) { 644 EXPECT_TRUE(false); 645 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalBackupOnAllBundlesFinished."; 646 } 647 GTEST_LOG_(INFO) 648 << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnAllBundlesFinished_0100"; 649 } 650 651 /** 652 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleStarted_0100 653 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleStarted_0100 654 * @tc.desc: Test function of IncrementalRestoreOnBundleStarted interface for SUCCESS. 655 * @tc.size: MEDIUM 656 * @tc.type: FUNC 657 * @tc.level Level 1 658 * @tc.require: I90ZZX 659 */ 660 HWTEST_F(ServiceReverseStubTest, 661 SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleStarted_0100, 662 testing::ext::TestSize.Level1) 663 { 664 GTEST_LOG_(INFO) 665 << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleStarted_0100"; 666 try { 667 MockServiceReverse service; 668 EXPECT_CALL(service, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return()); 669 MessageParcel data; 670 MessageParcel reply; 671 MessageOption option; 672 673 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 674 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 675 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 676 677 EXPECT_EQ( 678 BError(BError::Codes::OK), 679 service.OnRemoteRequest( 680 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_STARTED), 681 data, reply, option)); 682 } catch (...) { 683 EXPECT_TRUE(false); 684 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalRestoreOnBundleStarted."; 685 } 686 GTEST_LOG_(INFO) 687 << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleStarted_0100"; 688 } 689 690 /** 691 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleFinished_0100 692 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleFinished_0100 693 * @tc.desc: Test function of IncrementalRestoreOnBundleFinished interface for SUCCESS. 694 * @tc.size: MEDIUM 695 * @tc.type: FUNC 696 * @tc.level Level 1 697 * @tc.require: I90ZZX 698 */ 699 HWTEST_F(ServiceReverseStubTest, 700 SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleFinished_0100, 701 testing::ext::TestSize.Level1) 702 { 703 GTEST_LOG_(INFO) 704 << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleFinished_0100"; 705 try { 706 MockServiceReverse service; 707 EXPECT_CALL(service, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return()); 708 MessageParcel data; 709 MessageParcel reply; 710 MessageOption option; 711 712 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 713 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 714 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 715 716 EXPECT_EQ( 717 BError(BError::Codes::OK), 718 service.OnRemoteRequest( 719 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_FINISHED), 720 data, reply, option)); 721 } catch (...) { 722 EXPECT_TRUE(false); 723 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalRestoreOnBundleFinished."; 724 } 725 GTEST_LOG_(INFO) 726 << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleFinished_0100"; 727 } 728 729 /** 730 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalRestoreOnAllBundlesFinished_0100 731 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalRestoreOnAllBundlesFinished_0100 732 * @tc.desc: Test function of IncrementalRestoreOnAllBundlesFinished interface for SUCCESS. 733 * @tc.size: MEDIUM 734 * @tc.type: FUNC 735 * @tc.level Level 1 736 * @tc.require: I90ZZX 737 */ 738 HWTEST_F(ServiceReverseStubTest, 739 SUB_backup_ServiceReverseStub_IncrementalRestoreOnAllBundlesFinished_0100, 740 testing::ext::TestSize.Level1) 741 { 742 GTEST_LOG_(INFO) 743 << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalRestoreOnAllBundlesFinished_0100"; 744 try { 745 MockServiceReverse service; 746 EXPECT_CALL(service, IncrementalRestoreOnAllBundlesFinished(_)).WillOnce(Return()); 747 MessageParcel data; 748 MessageParcel reply; 749 MessageOption option; 750 751 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 752 EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); 753 754 EXPECT_EQ( 755 BError(BError::Codes::OK), 756 service.OnRemoteRequest( 757 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_TASK_FINISHED), 758 data, reply, option)); 759 } catch (...) { 760 EXPECT_TRUE(false); 761 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished."; 762 } 763 GTEST_LOG_(INFO) 764 << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnAllBundlesFinished_0100"; 765 } 766 767 /** 768 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalRestoreOnFileReady_0100 769 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalRestoreOnFileReady_0100 770 * @tc.desc: Test function of IncrementalRestoreOnFileReady interface for SUCCESS. 771 * @tc.size: MEDIUM 772 * @tc.type: FUNC 773 * @tc.level Level 1 774 * @tc.require: I90ZZX 775 */ 776 HWTEST_F(ServiceReverseStubTest, 777 SUB_backup_ServiceReverseStub_IncrementalRestoreOnFileReady_0100, 778 testing::ext::TestSize.Level1) 779 { 780 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalRestoreOnFileReady_0100"; 781 try { 782 MockServiceReverse service; 783 EXPECT_CALL(service, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); 784 MessageParcel data; 785 MessageParcel reply; 786 MessageOption option; 787 788 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 789 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 790 EXPECT_TRUE(data.WriteString(FILE_NAME)); 791 TestManager tm("ServiceReverseStub_0400"); 792 string filePath = tm.GetRootDirCurTest().append(FILE_NAME); 793 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); 794 data.WriteFileDescriptor(fd); 795 TestManager tm2("ServiceReverseStub_0401"); 796 string filePathManifest = tm2.GetRootDirCurTest().append(FILE_NAME_MANIFEST); 797 UniqueFd fdManifest(open(filePathManifest.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); 798 data.WriteFileDescriptor(fdManifest); 799 800 EXPECT_EQ(BError(BError::Codes::OK), 801 service.OnRemoteRequest( 802 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_FILE_READY), 803 data, reply, option)); 804 } catch (...) { 805 EXPECT_TRUE(false); 806 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalRestoreOnFileReady."; 807 } 808 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnFileReady_0100"; 809 } 810 811 /** 812 * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100 813 * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100 814 * @tc.desc: Test function of RestoreOnResultReport interface for SUCCESS. 815 * @tc.size: MEDIUM 816 * @tc.type: FUNC 817 * @tc.level Level 1 818 * @tc.require: I90ZZX 819 */ 820 HWTEST_F(ServiceReverseStubTest, 821 SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100, 822 testing::ext::TestSize.Level1) 823 { 824 GTEST_LOG_(INFO) 825 << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100"; 826 try { 827 MockServiceReverse service; 828 EXPECT_CALL(service, RestoreOnResultReport(_, _, _)).WillOnce(Return()); 829 MessageParcel data; 830 MessageParcel reply; 831 MessageOption option; 832 std::string resultReport = "result_report"; 833 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 834 EXPECT_TRUE(data.WriteString(resultReport)); 835 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 836 EXPECT_TRUE(data.WriteInt32(0)); 837 838 EXPECT_EQ( 839 BError(BError::Codes::OK), 840 service.OnRemoteRequest( 841 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_RESULT_REPORT), 842 data, reply, option)); 843 } catch (...) { 844 EXPECT_TRUE(false); 845 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnResultReport."; 846 } 847 GTEST_LOG_(INFO) 848 << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100"; 849 } 850 851 /** 852 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalRestoreOnResultReport_0100 853 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalRestoreOnResultReport_0100 854 * @tc.desc: Test function of IncrementalRestoreOnResultReport interface for SUCCESS. 855 * @tc.size: MEDIUM 856 * @tc.type: FUNC 857 * @tc.level Level 1 858 * @tc.require: I90ZZX 859 */ 860 HWTEST_F(ServiceReverseStubTest, 861 SUB_backup_ServiceReverseStub_IncrementalRestoreOnResultReport_0100, 862 testing::ext::TestSize.Level1) 863 { 864 GTEST_LOG_(INFO) 865 << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100"; 866 try { 867 MockServiceReverse service; 868 EXPECT_CALL(service, IncrementalRestoreOnResultReport(_, _, _)).WillOnce(Return()); 869 MessageParcel data; 870 MessageParcel reply; 871 MessageOption option; 872 std::string resultReport = "result_report"; 873 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 874 EXPECT_TRUE(data.WriteString(resultReport)); 875 EXPECT_TRUE(data.WriteInt32(0)); 876 877 EXPECT_EQ( 878 BError(BError::Codes::OK), 879 service.OnRemoteRequest( 880 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_RESULT_REPORT), 881 data, reply, option)); 882 } catch (...) { 883 EXPECT_TRUE(false); 884 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnResultReport."; 885 } 886 GTEST_LOG_(INFO) 887 << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnResultReport_0100"; 888 } 889 890 /** 891 * @tc.number: SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100 892 * @tc.name: SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100 893 * @tc.desc: Test function of BackupOnScanningInfo interface for SUCCESS. 894 * @tc.size: MEDIUM 895 * @tc.type: FUNC 896 * @tc.level Level 1 897 * @tc.require: I6F3GV 898 */ 899 HWTEST_F(ServiceReverseStubTest, 900 SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100, 901 testing::ext::TestSize.Level1) 902 { 903 GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100"; 904 try { 905 MockServiceReverse service; 906 EXPECT_CALL(service, BackupOnScanningInfo(_)).WillOnce(Return()); 907 MessageParcel data; 908 MessageParcel reply; 909 MessageOption option; 910 911 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 912 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 913 914 EXPECT_EQ(BError(BError::Codes::OK), 915 service.OnRemoteRequest( 916 static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SCANNED_INFO), data, 917 reply, option)); 918 } catch (...) { 919 EXPECT_TRUE(false); 920 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnScanningInfo."; 921 } 922 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100"; 923 } 924 925 /** 926 * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100 927 * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100 928 * @tc.desc: Test function of IncrementalBackupOnScanningInfo interface for SUCCESS. 929 * @tc.size: MEDIUM 930 * @tc.type: FUNC 931 * @tc.level Level 1 932 * @tc.require: I6F3GV 933 */ 934 HWTEST_F(ServiceReverseStubTest, 935 SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100, 936 testing::ext::TestSize.Level1) 937 { 938 GTEST_LOG_(INFO) << 939 "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100"; 940 try { 941 MockServiceReverse service; 942 MessageParcel data; 943 MessageParcel reply; 944 MessageOption option; 945 EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); 946 EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); 947 948 EXPECT_CALL(service, IncrementalBackupOnScanningInfo(_)).WillOnce(Return()); 949 EXPECT_EQ(BError(BError::Codes::OK), 950 service.OnRemoteRequest( 951 static_cast<uint32_t>( 952 IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SCANNED_INFO), 953 data, reply, option)); 954 } catch (...) { 955 EXPECT_TRUE(false); 956 GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnScanningInfo."; 957 } 958 GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100"; 959 } 960 } // namespace OHOS::FileManagement::Backup