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