• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <cstddef>
17 #include <cstdint>
18 #include <fcntl.h>
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21 #include <memory>
22 #include <sys/stat.h>
23 #include <sys/types.h>
24 
25 #include "b_error/b_error.h"
26 #include "b_resources/b_constants.h"
27 #include "ipc_types.h"
28 #include "i_service.h"
29 #include "message_parcel_mock.h"
30 #include "module_ipc/service_stub.h"
31 #include "service_reverse_mock.h"
32 #include "test_manager.h"
33 #include "unique_fd.h"
34 
35 namespace OHOS::FileManagement::Backup {
36 using namespace std;
37 using namespace testing;
38 
39 namespace {
40 const string BUNDLE_NAME = "com.example.app2backup";
41 const string FILE_NAME = "1.tar";
42 } // namespace
43 
44 class ServiceMock final : public ServiceStub {
45 public:
46     MOCK_METHOD1(InitRestoreSession, ErrCode(sptr<IServiceReverse> remote));
47     MOCK_METHOD1(InitBackupSession, ErrCode(sptr<IServiceReverse> remote));
48     MOCK_METHOD0(Start, ErrCode());
49     MOCK_METHOD0(GetLocalCapabilities, UniqueFd());
50     MOCK_METHOD1(PublishFile, ErrCode(const BFileInfo &fileInfo));
51     MOCK_METHOD3(AppFileReady, ErrCode(const string &fileName, UniqueFd fd, int32_t errCode));
52     MOCK_METHOD1(AppDone, ErrCode(ErrCode errCode));
53     MOCK_METHOD3(ServiceResultReport, ErrCode(const string restoreRetInfo,
54         BackupRestoreScenario scenario, ErrCode errCode));
55     MOCK_METHOD2(GetFileHandle, ErrCode(const string &bundleName, const string &fileName));
56     MOCK_METHOD5(AppendBundlesRestoreSession, ErrCode(UniqueFd fd, const std::vector<BundleName> &bundleNames,
57         const std::vector<std::string> &detailInfos, RestoreTypeEnum restoreType, int32_t userId));
58     MOCK_METHOD4(
59         AppendBundlesRestoreSession,
60         ErrCode(UniqueFd fd, const std::vector<BundleName> &bundleNames, RestoreTypeEnum restoreType, int32_t userId));
61     MOCK_METHOD1(AppendBundlesBackupSession, ErrCode(const std::vector<BundleName> &bundleNames));
62     MOCK_METHOD2(AppendBundlesDetailsBackupSession,
63                  ErrCode(const std::vector<BundleName> &bundleNames, const std::vector<std::string> &bundleInfos));
64     MOCK_METHOD0(Finish, ErrCode());
65     MOCK_METHOD0(Release, ErrCode());
66     MOCK_METHOD1(GetLocalCapabilitiesIncremental, UniqueFd(const std::vector<BIncrementalData> &bundleNames));
67     MOCK_METHOD0(GetAppLocalListAndDoIncrementalBackup, ErrCode());
68     MOCK_METHOD1(InitIncrementalBackupSession, ErrCode(sptr<IServiceReverse> remote));
69     MOCK_METHOD1(AppendBundlesIncrementalBackupSession, ErrCode(const std::vector<BIncrementalData> &bundlesToBackup));
70     MOCK_METHOD2(AppendBundlesIncrementalBackupSession,
71         ErrCode(const std::vector<BIncrementalData> &bundlesToBackup, const std::vector<std::string> &infos));
72 
73     MOCK_METHOD1(PublishIncrementalFile, ErrCode(const BFileInfo &fileInfo));
74     MOCK_METHOD2(PublishSAIncrementalFile, ErrCode(const BFileInfo &fileInfo, UniqueFd fd));
75     MOCK_METHOD4(AppIncrementalFileReady, ErrCode(const std::string &fileName, UniqueFd fd, UniqueFd manifestFd,
76         int32_t errCode));
77     MOCK_METHOD1(AppIncrementalDone, ErrCode(ErrCode errCode));
78     MOCK_METHOD2(GetIncrementalFileHandle, ErrCode(const std::string &bundleName, const std::string &fileName));
79     MOCK_METHOD2(GetBackupInfo, ErrCode(string &bundleName, string &result));
80     MOCK_METHOD3(UpdateTimer, ErrCode(BundleName &bundleName, uint32_t timeout, bool &result));
81     MOCK_METHOD1(StartExtTimer, ErrCode(bool &isExtStart));
82     MOCK_METHOD1(StartFwkTimer, ErrCode(bool &isFwkStart));
83     MOCK_METHOD3(UpdateSendRate, ErrCode(std::string &bundleName, int32_t sendRate, bool &result));
84     MOCK_METHOD2(ReportAppProcessInfo, ErrCode(const std::string processInfo, BackupRestoreScenario sennario));
85 };
86 
87 class ServiceStubTest : public testing::Test {
88 public:
89     static void SetUpTestCase(void);
90     static void TearDownTestCase();
SetUp()91     void SetUp() override {};
TearDown()92     void TearDown() override {};
93 public:
94     static inline shared_ptr<MessageParcelMock> messageParcelMock = nullptr;
95     static inline shared_ptr<ServiceMock> service = nullptr;
96     static inline shared_ptr<IfaceCastMock> castMock = nullptr;
97     static inline sptr<ServiceReverseMock> remote = nullptr;
98 };
99 
SetUpTestCase(void)100 void ServiceStubTest::SetUpTestCase(void)
101 {
102     remote = sptr(new ServiceReverseMock());
103     service = make_shared<ServiceMock>();
104     messageParcelMock = make_shared<MessageParcelMock>();
105     MessageParcelMock::messageParcel = messageParcelMock;
106     castMock = std::make_shared<IfaceCastMock>();
107     IfaceCastMock::cast = castMock;
108 }
TearDownTestCase()109 void ServiceStubTest::TearDownTestCase()
110 {
111     remote = nullptr;
112     service = nullptr;
113     MessageParcelMock::messageParcel = nullptr;
114     messageParcelMock = nullptr;
115     IfaceCastMock::cast = nullptr;
116     castMock = nullptr;
117 }
118 
119 /**
120  * @tc.number: SUB_backup_sa_ServiceStub_OnRemoteRequest_0100
121  * @tc.name: SUB_backup_sa_ServiceStub_OnRemoteRequest_0100
122  * @tc.desc: Test function of OnRemoteRequest interface for SUCCESS.
123  * @tc.size: MEDIUM
124  * @tc.type: FUNC
125  * @tc.level Level 1
126  * @tc.require: I9OVHB
127  */
128 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_OnRemoteRequest_0100, testing::ext::TestSize.Level1)
129 {
130     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_OnRemoteRequest_0100";
131     try {
132         MessageParcel data;
133         MessageParcel reply;
134         MessageOption option;
135         EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(u16string()));
136         EXPECT_TRUE(service != nullptr);
137         auto err = service->OnRemoteRequest(0, data, reply, option);
138         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
139 
140         const std::u16string descriptor = ServiceStub::GetDescriptor();
141         EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(descriptor));
142         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
143         err = service->OnRemoteRequest(static_cast<uint32_t>(IServiceInterfaceCode::SERVICE_CMD_GET_FILE_NAME),
144             data, reply, option);
145         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
146 
147         EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(descriptor));
148         auto ret = service->OnRemoteRequest(-1, data, reply, option);
149         EXPECT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR);
150     } catch (...) {
151         EXPECT_TRUE(false);
152         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitRestoreSession.";
153     }
154     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_OnRemoteRequest_0100";
155 }
156 
157 /**
158  * @tc.number: SUB_backup_sa_ServiceStub_InitRestoreSession_0100
159  * @tc.name: SUB_backup_sa_ServiceStub_InitRestoreSession_0100
160  * @tc.desc: Test function of InitRestoreSession interface for SUCCESS.
161  * @tc.size: MEDIUM
162  * @tc.type: FUNC
163  * @tc.level Level 1
164  * @tc.require: I6F3GV
165  */
166 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitRestoreSession_0100, testing::ext::TestSize.Level1)
167 {
168     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_InitRestoreSession_0100";
169     try {
170         MessageParcel data;
171         MessageParcel reply;
172         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr));
173         EXPECT_TRUE(service != nullptr);
174         auto err = service->CmdInitRestoreSession(data, reply);
175         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
176 
177         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote));
178         EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(nullptr));
179         err = service->CmdInitRestoreSession(data, reply);
180         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
181 
182         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote));
183         EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote));
184         EXPECT_CALL(*service, InitRestoreSession(_)).WillOnce(Return(BError(BError::Codes::OK)));
185         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
186         err = service->CmdInitRestoreSession(data, reply);
187         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
188 
189         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote));
190         EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote));
191         EXPECT_CALL(*service, InitRestoreSession(_)).WillOnce(Return(BError(BError::Codes::OK)));
192         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
193         auto ret = service->CmdInitRestoreSession(data, reply);
194         EXPECT_EQ(ret, BError(BError::Codes::OK));
195     } catch (...) {
196         EXPECT_TRUE(false);
197         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitRestoreSession.";
198     }
199     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitRestoreSession_0100";
200 }
201 
202 /**
203  * @tc.number: SUB_backup_sa_ServiceStub_InitBackupSession_0100
204  * @tc.name: SUB_backup_sa_ServiceStub_InitBackupSession_0100
205  * @tc.desc: Test function of InitBackupSession interface for SUCCESS.
206  * @tc.size: MEDIUM
207  * @tc.type: FUNC
208  * @tc.level Level 1
209  * @tc.require: I6F3GV
210  */
211 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitBackupSession_0100, testing::ext::TestSize.Level1)
212 {
213     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_InitBackupSession_0100";
214     try {
215         MessageParcel data;
216         MessageParcel reply;
217         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr));
218         EXPECT_TRUE(service != nullptr);
219         auto err = service->CmdInitBackupSession(data, reply);
220         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
221 
222         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote));
223         EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(nullptr));
224         err = service->CmdInitBackupSession(data, reply);
225         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
226 
227         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote));
228         EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote));
229         EXPECT_CALL(*service, InitBackupSession(_)).WillOnce(Return(BError(BError::Codes::OK)));
230         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
231         err = service->CmdInitBackupSession(data, reply);
232         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
233 
234         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote));
235         EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote));
236         EXPECT_CALL(*service, InitBackupSession(_)).WillOnce(Return(BError(BError::Codes::OK)));
237         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
238         auto ret = service->CmdInitBackupSession(data, reply);
239         EXPECT_EQ(ret, BError(BError::Codes::OK));
240     } catch (...) {
241         EXPECT_TRUE(false);
242         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitBackupSession.";
243     }
244     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitBackupSession_0100";
245 }
246 
247 /**
248  * @tc.number: SUB_backup_sa_ServiceStub_Start_0100
249  * @tc.name: SUB_backup_sa_ServiceStub_Start_0100
250  * @tc.desc: Test function of Start interface for SUCCESS.
251  * @tc.size: MEDIUM
252  * @tc.type: FUNC
253  * @tc.level Level 1
254  * @tc.require: I6F3GV
255  */
256 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Start_0100, testing::ext::TestSize.Level1)
257 {
258     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_Start_0100";
259     try {
260         MessageParcel data;
261         MessageParcel reply;
262         EXPECT_CALL(*service, Start()).WillOnce(Return(BError(BError::Codes::OK)));
263         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
264         EXPECT_TRUE(service != nullptr);
265         auto err = service->CmdStart(data, reply);
266         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
267 
268         EXPECT_CALL(*service, Start()).WillOnce(Return(BError(BError::Codes::OK)));
269         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
270         auto ret = service->CmdStart(data, reply);
271         EXPECT_EQ(ret, BError(BError::Codes::OK));
272     } catch (...) {
273         EXPECT_TRUE(false);
274         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by Start.";
275     }
276     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_Start_0100";
277 }
278 
279 /**
280  * @tc.number: SUB_backup_sa_ServiceStub_GetLocalCapabilities_0100
281  * @tc.name: SUB_backup_sa_ServiceStub_GetLocalCapabilities_0100
282  * @tc.desc: Test function of GetLocalCapabilities interface for SUCCESS.
283  * @tc.size: MEDIUM
284  * @tc.type: FUNC
285  * @tc.level Level 1
286  * @tc.require: I6F3GV
287  */
288 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetLocalCapabilities_0100, testing::ext::TestSize.Level1)
289 {
290     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_GetLocalCapabilities_0100";
291     try {
292         MessageParcel data;
293         MessageParcel reply;
294         EXPECT_CALL(*service, GetLocalCapabilities()).WillOnce(Return(UniqueFd(0)));
295         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false));
296         EXPECT_TRUE(service != nullptr);
297         auto err = service->CmdGetLocalCapabilities(data, reply);
298         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
299 
300         EXPECT_CALL(*service, GetLocalCapabilities()).WillOnce(Return(UniqueFd(0)));
301         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true));
302         auto ret = service->CmdGetLocalCapabilities(data, reply);
303         EXPECT_EQ(ret, BError(BError::Codes::OK));
304     } catch (...) {
305         EXPECT_TRUE(false);
306         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by GetLocalCapabilities.";
307     }
308     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_GetLocalCapabilities_0100";
309 }
310 
311 /**
312  * @tc.number: SUB_backup_sa_ServiceStub_PublishFile_0100
313  * @tc.name: SUB_backup_sa_ServiceStub_PublishFile_0100
314  * @tc.desc: Test function of PublishFile interface for SUCCESS.
315  * @tc.size: MEDIUM
316  * @tc.type: FUNC
317  * @tc.level Level 1
318  * @tc.require: I6F3GV
319  */
320 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishFile_0100, testing::ext::TestSize.Level1)
321 {
322     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_PublishFile_0100";
323     try {
324         MessageParcel data;
325         MessageParcel reply;
326         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
327         EXPECT_TRUE(service != nullptr);
328         auto err = service->CmdPublishFile(data, reply);
329         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
330 
331         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1));
332         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true));
333         EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true));
334         EXPECT_CALL(*service, PublishFile(_)).WillOnce(Return(0));
335         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
336         err = service->CmdPublishFile(data, reply);
337         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
338 
339         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1));
340         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true));
341         EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true));
342         EXPECT_CALL(*service, PublishFile(_)).WillOnce(Return(0));
343         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
344         auto ret = service->CmdPublishFile(data, reply);
345         EXPECT_EQ(ret, BError(BError::Codes::OK));
346     } catch (...) {
347         EXPECT_TRUE(false);
348         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by PublishFile.";
349     }
350     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_PublishFile_0100";
351 }
352 
353 /**
354  * @tc.number: SUB_backup_sa_ServiceStub_AppFileReady_0100
355  * @tc.name: SUB_backup_sa_ServiceStub_AppFileReady_0100
356  * @tc.desc: Test function of AppFileReady interface for FAILURE.
357  * @tc.size: MEDIUM
358  * @tc.type: FUNC
359  * @tc.level Level 1
360  * @tc.require: I6F3GV
361  */
362 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppFileReady_0100, testing::ext::TestSize.Level1)
363 {
364     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppFileReady_0100";
365     try {
366         MessageParcel data;
367         MessageParcel reply;
368         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
369         EXPECT_TRUE(service != nullptr);
370         auto err = service->CmdAppFileReady(data, reply);
371         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
372 
373         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
374         EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
375         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(-1));
376         err = service->CmdAppFileReady(data, reply);
377         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
378 
379         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
380         EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
381         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
382         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
383         EXPECT_CALL(*service, AppFileReady(_, _, _)).WillOnce(Return(0));
384         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
385         err = service->CmdAppFileReady(data, reply);
386         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
387 
388         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
389         EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(false));
390         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
391         EXPECT_CALL(*service, AppFileReady(_, _, _)).WillOnce(Return(0));
392         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
393         err = service->CmdAppFileReady(data, reply);
394         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
395     } catch (...) {
396         EXPECT_TRUE(false);
397         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppFileReady.";
398     }
399     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppFileReady_0100";
400 }
401 
402 /**
403  * @tc.number: SUB_backup_sa_ServiceStub_AppFileReady_0101
404  * @tc.name: SUB_backup_sa_ServiceStub_AppFileReady_0101
405  * @tc.desc: Test function of AppFileReady interface for SUCCESS.
406  * @tc.size: MEDIUM
407  * @tc.type: FUNC
408  * @tc.level Level 1
409  * @tc.require: I6F3GV
410  */
411 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppFileReady_0101, testing::ext::TestSize.Level1)
412 {
413     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppFileReady_0101";
414     try {
415         MessageParcel data;
416         MessageParcel reply;
417         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
418         EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(false));
419         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
420         EXPECT_CALL(*service, AppFileReady(_, _, _)).WillOnce(Return(0));
421         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
422         EXPECT_TRUE(service != nullptr);
423         auto ret = service->CmdAppFileReady(data, reply);
424         EXPECT_EQ(ret, BError(BError::Codes::OK));
425     } catch (...) {
426         EXPECT_TRUE(false);
427         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppFileReady.";
428     }
429     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppFileReady_0101";
430 }
431 
432 /**
433  * @tc.number: SUB_backup_sa_ServiceStub_AppDone_0100
434  * @tc.name: SUB_backup_sa_ServiceStub_AppDone_0100
435  * @tc.desc: Test function of AppDone interface for SUCCESS.
436  * @tc.size: MEDIUM
437  * @tc.type: FUNC
438  * @tc.level Level 1
439  * @tc.require: I6F3GV
440  */
441 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppDone_0100, testing::ext::TestSize.Level1)
442 {
443     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppDone_0100";
444     try {
445         MessageParcel data;
446         MessageParcel reply;
447         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
448         EXPECT_TRUE(service != nullptr);
449         auto err = service->CmdAppDone(data, reply);
450         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
451 
452         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
453         EXPECT_CALL(*service, AppDone(_)).WillOnce(Return(0));
454         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
455         err = service->CmdAppDone(data, reply);
456         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
457 
458         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
459         EXPECT_CALL(*service, AppDone(_)).WillOnce(Return(0));
460         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
461         auto ret = service->CmdAppDone(data, reply);
462         EXPECT_EQ(ret, BError(BError::Codes::OK));
463     } catch (...) {
464         EXPECT_TRUE(false);
465         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppDone.";
466     }
467     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppDone_0100";
468 }
469 
470 /**
471  * @tc.number: SUB_backup_sa_ServiceStub_GetFileHandle_0100
472  * @tc.name: SUB_backup_sa_ServiceStub_GetFileHandle_0100
473  * @tc.desc: Test function of GetFileHandle interface for SUCCESS.
474  * @tc.size: MEDIUM
475  * @tc.type: FUNC
476  * @tc.level Level 1
477  * @tc.require: I6F3GV
478  */
479 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetFileHandle_0100, testing::ext::TestSize.Level1)
480 {
481     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_GetFileHandle_0100";
482     try {
483         MessageParcel data;
484         MessageParcel reply;
485         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
486         EXPECT_TRUE(service != nullptr);
487         auto err = service->CmdGetFileHandle(data, reply);
488         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
489 
490         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(false));
491         err = service->CmdGetFileHandle(data, reply);
492         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
493 
494         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true));
495         EXPECT_CALL(*service, GetFileHandle(_, _)).WillOnce(Return(BError(BError::Codes::OK)));
496         auto ret = service->CmdGetFileHandle(data, reply);
497         EXPECT_EQ(ret, BError(BError::Codes::OK));
498     } catch (...) {
499         EXPECT_TRUE(false);
500         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by GetFileHandle.";
501     }
502     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_GetFileHandle_0100";
503 }
504 
505 /**
506  * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100
507  * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100
508  * @tc.desc: Test function of AppendBundlesRestoreSession interface for FAILURE.
509  * @tc.size: MEDIUM
510  * @tc.type: FUNC
511  * @tc.level Level 1
512  * @tc.require: I6URNZ
513  */
514 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100, testing::ext::TestSize.Level1)
515 {
516     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100";
517     try {
518         MessageParcel data;
519         MessageParcel reply;
520         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(-1));
521         EXPECT_TRUE(service != nullptr);
522         auto err = service->CmdAppendBundlesRestoreSession(data, reply);
523         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
524 
525         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
526         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(false));
527         err = service->CmdAppendBundlesRestoreSession(data, reply);
528         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
529 
530         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
531         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true));
532         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
533         err = service->CmdAppendBundlesRestoreSession(data, reply);
534         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
535     } catch (...) {
536         EXPECT_TRUE(false);
537         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesRestoreSession.";
538     }
539     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100";
540 }
541 
542 /**
543  * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0101
544  * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0101
545  * @tc.desc: Test function of AppendBundlesRestoreSession interface for FAILURE.
546  * @tc.size: MEDIUM
547  * @tc.type: FUNC
548  * @tc.level Level 1
549  * @tc.require: I6URNZ
550  */
551 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0101, testing::ext::TestSize.Level1)
552 {
553     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0101";
554     try {
555         MessageParcel data;
556         MessageParcel reply;
557         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
558         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true));
559         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
560         EXPECT_TRUE(service != nullptr);
561         auto err = service->CmdAppendBundlesRestoreSession(data, reply);
562         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
563 
564         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
565         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true));
566         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
567         EXPECT_CALL(*service, AppendBundlesRestoreSession(_, _, _, _)).WillOnce(Return(BError(BError::Codes::OK)));
568         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
569         err = service->CmdAppendBundlesRestoreSession(data, reply);
570         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
571     } catch (...) {
572         EXPECT_TRUE(false);
573         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesRestoreSession.";
574     }
575     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0101";
576 }
577 
578 /**
579  * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0102
580  * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0102
581  * @tc.desc: Test function of AppendBundlesRestoreSession interface for SUCCESS.
582  * @tc.size: MEDIUM
583  * @tc.type: FUNC
584  * @tc.level Level 1
585  * @tc.require: I6URNZ
586  */
587 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0102, testing::ext::TestSize.Level1)
588 {
589     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0102";
590     try {
591         MessageParcel data;
592         MessageParcel reply;
593         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
594         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true));
595         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
596         EXPECT_TRUE(service != nullptr);
597         EXPECT_CALL(*service, AppendBundlesRestoreSession(_, _, _, _)).WillOnce(Return(BError(BError::Codes::OK)));
598         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
599         auto ret = service->CmdAppendBundlesRestoreSession(data, reply);
600         EXPECT_EQ(ret, BError(BError::Codes::OK));
601     } catch (...) {
602         EXPECT_TRUE(false);
603         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesRestoreSession.";
604     }
605     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0102";
606 }
607 
608 /**
609  * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesBackupSession_0100
610  * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesBackupSession_0100
611  * @tc.desc: Test function of AppendBundlesBackupSession interface for SUCCESS.
612  * @tc.size: MEDIUM
613  * @tc.type: FUNC
614  * @tc.level Level 1
615  * @tc.require: I6URNZ
616  */
617 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesBackupSession_0100, testing::ext::TestSize.Level1)
618 {
619     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesBackupSession_0100";
620     try {
621         MessageParcel data;
622         MessageParcel reply;
623         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(false));
624         EXPECT_TRUE(service != nullptr);
625         auto err = service->CmdAppendBundlesBackupSession(data, reply);
626         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
627 
628         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true));
629         EXPECT_CALL(*service, AppendBundlesBackupSession(_)).WillOnce(Return(BError(BError::Codes::OK)));
630         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
631         err = service->CmdAppendBundlesBackupSession(data, reply);
632         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
633 
634         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true));
635         EXPECT_CALL(*service, AppendBundlesBackupSession(_)).WillOnce(Return(BError(BError::Codes::OK)));
636         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
637         auto ret = service->CmdAppendBundlesBackupSession(data, reply);
638         EXPECT_EQ(ret, BError(BError::Codes::OK));
639     } catch (...) {
640         EXPECT_TRUE(false);
641         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesBackupSession.";
642     }
643     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesBackupSession_0100";
644 }
645 
646 /**
647  * @tc.number: SUB_backup_sa_ServiceStub_Finish_0100
648  * @tc.name: SUB_backup_sa_ServiceStub_Finish_0100
649  * @tc.desc: Test function of Finish interface for SUCCESS.
650  * @tc.size: MEDIUM
651  * @tc.type: FUNC
652  * @tc.level Level 1
653  * @tc.require: I6URNZ
654  */
655 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Finish_0100, testing::ext::TestSize.Level1)
656 {
657     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_Finish_0100";
658     try {
659         MessageParcel data;
660         MessageParcel reply;
661         EXPECT_TRUE(service != nullptr);
662         EXPECT_CALL(*service, Finish()).WillOnce(Return(0));
663         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
664         auto err = service->CmdFinish(data, reply);
665         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
666 
667         EXPECT_CALL(*service, Finish()).WillOnce(Return(0));
668         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
669         auto ret = service->CmdFinish(data, reply);
670         EXPECT_EQ(ret, BError(BError::Codes::OK));
671     } catch (...) {
672         EXPECT_TRUE(false);
673         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by Finish.";
674     }
675     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_Finish_0100";
676 }
677 
678 /**
679  * @tc.number: SUB_backup_sa_ServiceStub_Release_0100
680  * @tc.name: SUB_backup_sa_ServiceStub_Release_0100
681  * @tc.desc: Test function of Release interface for SUCCESS.
682  * @tc.size: MEDIUM
683  * @tc.type: FUNC
684  * @tc.level Level 1
685  * @tc.require: I6URNZ
686  */
687 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Release_0100, testing::ext::TestSize.Level1)
688 {
689     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_Release_0100";
690     try {
691         MessageParcel data;
692         MessageParcel reply;
693         EXPECT_TRUE(service != nullptr);
694         EXPECT_CALL(*service, Release()).WillOnce(Return(0));
695         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
696         auto err = service->CmdRelease(data, reply);
697         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
698 
699         EXPECT_CALL(*service, Release()).WillOnce(Return(0));
700         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
701         auto ret = service->CmdRelease(data, reply);
702         EXPECT_EQ(ret, BError(BError::Codes::OK));
703     } catch (...) {
704         EXPECT_TRUE(false);
705         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by Release.";
706     }
707     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_Release_0100";
708 }
709 
710 /**
711  * @tc.number: SUB_backup_sa_ServiceStub_GetBackupInfo_0100
712  * @tc.name: SUB_backup_sa_ServiceStub_GetBackupInfo_0100
713  * @tc.desc: Test function of GetBackupInfo interface for SUCCESS.
714  * @tc.size: MEDIUM
715  * @tc.type: FUNC
716  * @tc.level Level 1
717  * @tc.require: I6URNZ
718  */
719 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetBackupInfo_0100, testing::ext::TestSize.Level1)
720 {
721     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_GetBackupInfo_0100";
722     try {
723         MessageParcel data;
724         MessageParcel reply;
725         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
726         EXPECT_TRUE(service != nullptr);
727         auto err = service->CmdGetBackupInfo(data, reply);
728         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
729 
730         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
731         EXPECT_CALL(*service, GetBackupInfo(_, _)).WillOnce(Return(-1));
732         err = service->CmdGetBackupInfo(data, reply);
733         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
734 
735         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
736         EXPECT_CALL(*service, GetBackupInfo(_, _)).WillOnce(Return(0));
737         EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(false));
738         err = service->CmdGetBackupInfo(data, reply);
739         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
740 
741         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
742         EXPECT_CALL(*service, GetBackupInfo(_, _)).WillOnce(Return(0));
743         EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true));
744         auto ret = service->CmdGetBackupInfo(data, reply);
745         EXPECT_EQ(ret, BError(BError::Codes::OK));
746     } catch (...) {
747         EXPECT_TRUE(false);
748         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by GetBackupInfo.";
749     }
750     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_GetBackupInfo_0100";
751 }
752 
753 /**
754  * @tc.number: SUB_backup_sa_ServiceStub_UpdateTimer_0100
755  * @tc.name: SUB_backup_sa_ServiceStub_UpdateTimer_0100
756  * @tc.desc: Test function of UpdateTimer interface for SUCCESS.
757  * @tc.size: MEDIUM
758  * @tc.type: FUNC
759  * @tc.level Level 1
760  * @tc.require: I6URNZ
761  */
762 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_UpdateTimer_0100, testing::ext::TestSize.Level1)
763 {
764     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_UpdateTimer_0100";
765     try {
766         MessageParcel data;
767         MessageParcel reply;
768         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
769         EXPECT_TRUE(service != nullptr);
770         auto err = service->CmdUpdateTimer(data, reply);
771         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
772 
773         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
774         EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(false));
775         err = service->CmdUpdateTimer(data, reply);
776         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
777 
778         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
779         EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true));
780         EXPECT_CALL(*service, UpdateTimer(_, _, _)).WillOnce(Return(-1));
781         err = service->CmdUpdateTimer(data, reply);
782         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
783     } catch (...) {
784         EXPECT_TRUE(false);
785         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by UpdateTimer.";
786     }
787     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_UpdateTimer_0100";
788 }
789 
790 /**
791  * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0100
792  * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0100
793  * @tc.desc: Test function of AppendBundlesDetailsRestoreSession interface for FAILURE.
794  * @tc.size: MEDIUM
795  * @tc.type: FUNC
796  * @tc.level Level 1
797  * @tc.require: I6URNZ
798  */
799 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0100,
800     testing::ext::TestSize.Level1)
801 {
802     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0100";
803     try {
804         MessageParcel data;
805         MessageParcel reply;
806         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(-1));
807         EXPECT_TRUE(service != nullptr);
808         auto err = service->CmdAppendBundlesDetailsRestoreSession(data, reply);
809         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
810 
811         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
812         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(false));
813         err = service->CmdAppendBundlesDetailsRestoreSession(data, reply);
814         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
815 
816         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
817         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(false));
818         err = service->CmdAppendBundlesDetailsRestoreSession(data, reply);
819         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
820 
821         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
822         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true));
823         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
824         err = service->CmdAppendBundlesDetailsRestoreSession(data, reply);
825         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
826     } catch (...) {
827         EXPECT_TRUE(false);
828         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesDetailsRestoreSession.";
829     }
830     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0100";
831 }
832 
833 /**
834  * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0101
835  * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0101
836  * @tc.desc: Test function of AppendBundlesDetailsRestoreSession interface for SUCCESS.
837  * @tc.size: MEDIUM
838  * @tc.type: FUNC
839  * @tc.level Level 1
840  * @tc.require: I6URNZ
841  */
842 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0101,
843     testing::ext::TestSize.Level1)
844 {
845     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0101";
846     try {
847         MessageParcel data;
848         MessageParcel reply;
849         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
850         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true));
851         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
852         EXPECT_TRUE(service != nullptr);
853         auto err = service->CmdAppendBundlesDetailsRestoreSession(data, reply);
854         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
855 
856         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
857         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true));
858         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
859         EXPECT_CALL(*service, AppendBundlesRestoreSession(_, _, _, _, _)).WillOnce(Return(0));
860         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
861         err = service->CmdAppendBundlesDetailsRestoreSession(data, reply);
862         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
863 
864         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
865         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true));
866         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
867         EXPECT_CALL(*service, AppendBundlesRestoreSession(_, _, _, _, _)).WillOnce(Return(0));
868         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
869         auto ret = service->CmdAppendBundlesDetailsRestoreSession(data, reply);
870         EXPECT_EQ(ret, BError(BError::Codes::OK));
871     } catch (...) {
872         EXPECT_TRUE(false);
873         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesDetailsRestoreSession.";
874     }
875     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0101";
876 }
877 
878 /**
879  * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSession_0100
880  * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSession_0100
881  * @tc.desc: Test function of AppendBundlesDetailsBackupSession interface for SUCCESS.
882  * @tc.size: MEDIUM
883  * @tc.type: FUNC
884  * @tc.level Level 1
885  * @tc.require: I6URNZ
886  */
887 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSession_0100,
888     testing::ext::TestSize.Level1)
889 {
890     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSession_0100";
891     try {
892         MessageParcel data;
893         MessageParcel reply;
894         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(false));
895         EXPECT_TRUE(service != nullptr);
896         auto err = service->CmdAppendBundlesDetailsBackupSession(data, reply);
897         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
898 
899         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(false));
900         err = service->CmdAppendBundlesDetailsBackupSession(data, reply);
901         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
902 
903         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true));
904         EXPECT_CALL(*service, AppendBundlesDetailsBackupSession(_, _)).WillOnce(Return(0));
905         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
906         err = service->CmdAppendBundlesDetailsBackupSession(data, reply);
907         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
908 
909         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true));
910         EXPECT_CALL(*service, AppendBundlesDetailsBackupSession(_, _)).WillOnce(Return(0));
911         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
912         auto ret = service->CmdAppendBundlesDetailsBackupSession(data, reply);
913         EXPECT_EQ(ret, BError(BError::Codes::OK));
914     } catch (...) {
915         EXPECT_TRUE(false);
916         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesDetailsBackupSession.";
917     }
918     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSession_0100";
919 }
920 
921 /**
922  * @tc.number: SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremental_0100
923  * @tc.name: SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremental_0100
924  * @tc.desc: Test function of GetLocalCapabilitiesIncremental interface for SUCCESS.
925  * @tc.size: MEDIUM
926  * @tc.type: FUNC
927  * @tc.level Level 1
928  * @tc.require: I6F3GV
929  */
930 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremental_0100, testing::ext::TestSize.Level1)
931 {
932     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremental_0100";
933     try {
934         MessageParcel data;
935         MessageParcel reply;
936         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
937         EXPECT_TRUE(service != nullptr);
938         auto err = service->CmdGetLocalCapabilitiesIncremental(data, reply);
939         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
940 
941         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(1), Return(true)));
942         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
943         err = service->CmdGetLocalCapabilitiesIncremental(data, reply);
944         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
945 
946         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
947         EXPECT_CALL(*service, GetLocalCapabilitiesIncremental(_)).WillOnce(Return(UniqueFd(0)));
948         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false));
949         err = service->CmdGetLocalCapabilitiesIncremental(data, reply);
950         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
951 
952         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
953         EXPECT_CALL(*service, GetLocalCapabilitiesIncremental(_)).WillOnce(Return(UniqueFd(0)));
954         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true));
955         auto ret = service->CmdGetLocalCapabilitiesIncremental(data, reply);
956         EXPECT_EQ(ret, BError(BError::Codes::OK));
957     } catch (...) {
958         EXPECT_TRUE(false);
959         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by GetLocalCapabilitiesIncremental.";
960     }
961     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremental_0100";
962 }
963 
964 /**
965  * @tc.number: SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100
966  * @tc.name: SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100
967  * @tc.desc: Test function of InitIncrementalBackupSession interface for SUCCESS.
968  * @tc.size: MEDIUM
969  * @tc.type: FUNC
970  * @tc.level Level 1
971  * @tc.require: I6URNZ
972  */
973 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100, testing::ext::TestSize.Level1)
974 {
975     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100";
976     try {
977         MessageParcel data;
978         MessageParcel reply;
979         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr));
980         EXPECT_TRUE(service != nullptr);
981         auto err = service->CmdInitIncrementalBackupSession(data, reply);
982         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
983 
984         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote));
985         EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(nullptr));
986         err = service->CmdInitIncrementalBackupSession(data, reply);
987         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
988 
989         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote));
990         EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote));
991         EXPECT_CALL(*service, InitIncrementalBackupSession(_)).WillOnce(Return(0));
992         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
993         err = service->CmdInitIncrementalBackupSession(data, reply);
994         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
995 
996         EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote));
997         EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote));
998         EXPECT_CALL(*service, InitIncrementalBackupSession(_)).WillOnce(Return(0));
999         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
1000         auto ret = service->CmdInitIncrementalBackupSession(data, reply);
1001         EXPECT_EQ(ret, BError(BError::Codes::OK));
1002     } catch (...) {
1003         EXPECT_TRUE(false);
1004         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitIncrementalBackupSession.";
1005     }
1006     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100";
1007 }
1008 
1009 /**
1010  * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0100
1011  * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0100
1012  * @tc.desc: Test function of AppendBundlesIncrementalBackupSession interface for SUCCESS.
1013  * @tc.size: MEDIUM
1014  * @tc.type: FUNC
1015  * @tc.level Level 1
1016  * @tc.require: I6URNZ
1017  */
1018 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0100,
1019     testing::ext::TestSize.Level1)
1020 {
1021     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0100";
1022     try {
1023         MessageParcel data;
1024         MessageParcel reply;
1025         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
1026         EXPECT_TRUE(service != nullptr);
1027         auto err = service->CmdAppendBundlesIncrementalBackupSession(data, reply);
1028         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1029 
1030         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(1), Return(true)));
1031         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
1032         err = service->CmdAppendBundlesIncrementalBackupSession(data, reply);
1033         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1034 
1035         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
1036         EXPECT_CALL(*service, AppendBundlesIncrementalBackupSession(_)).WillOnce(Return(0));
1037         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
1038         err = service->CmdAppendBundlesIncrementalBackupSession(data, reply);
1039         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1040 
1041         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
1042         EXPECT_CALL(*service, AppendBundlesIncrementalBackupSession(_)).WillOnce(Return(0));
1043         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
1044         auto ret = service->CmdAppendBundlesIncrementalBackupSession(data, reply);
1045         EXPECT_EQ(ret, BError(BError::Codes::OK));
1046     } catch (...) {
1047         EXPECT_TRUE(false);
1048         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesIncrementalBackupSession.";
1049     }
1050     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100";
1051 }
1052 
1053 /**
1054  * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0101
1055  * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0101
1056  * @tc.desc: Test function of AppendBundlesIncrementalBackupSession interface for SUCCESS.
1057  * @tc.size: MEDIUM
1058  * @tc.type: FUNC
1059  * @tc.level Level 1
1060  * @tc.require: I6URNZ
1061  */
1062 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0101,
1063     testing::ext::TestSize.Level1)
1064 {
1065     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0101";
1066     try {
1067         MessageParcel data;
1068         MessageParcel reply;
1069         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
1070         EXPECT_TRUE(service != nullptr);
1071         auto err = service->CmdAppendBundlesDetailsIncrementalBackupSession(data, reply);
1072         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1073 
1074         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(1), Return(true)));
1075         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
1076         err = service->CmdAppendBundlesDetailsIncrementalBackupSession(data, reply);
1077         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1078 
1079         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
1080         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true));
1081         EXPECT_CALL(*service, AppendBundlesIncrementalBackupSession(_, _)).WillOnce(Return(0));
1082         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
1083         err = service->CmdAppendBundlesDetailsIncrementalBackupSession(data, reply);
1084         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1085 
1086         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
1087         EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true));
1088         EXPECT_CALL(*service, AppendBundlesIncrementalBackupSession(_, _)).WillOnce(Return(0));
1089         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
1090         auto ret = service->CmdAppendBundlesDetailsIncrementalBackupSession(data, reply);
1091         EXPECT_EQ(ret, BError(BError::Codes::OK));
1092     } catch (...) {
1093         EXPECT_TRUE(false);
1094         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesIncrementalBackupSession.";
1095     }
1096     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0101";
1097 }
1098 
1099 /**
1100  * @tc.number: SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100
1101  * @tc.name: SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100
1102  * @tc.desc: Test function of PublishIncrementalFile interface for SUCCESS.
1103  * @tc.size: MEDIUM
1104  * @tc.type: FUNC
1105  * @tc.level Level 1
1106  * @tc.require: I6F3GV
1107  */
1108 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100, testing::ext::TestSize.Level1)
1109 {
1110     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100";
1111     try {
1112         MessageParcel data;
1113         MessageParcel reply;
1114         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
1115         EXPECT_TRUE(service != nullptr);
1116         auto err = service->CmdPublishIncrementalFile(data, reply);
1117         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1118 
1119         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1));
1120         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1121         EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true));
1122         EXPECT_CALL(*service, PublishIncrementalFile(_)).WillOnce(Return(0));
1123         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
1124         err = service->CmdPublishIncrementalFile(data, reply);
1125         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1126 
1127         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1));
1128         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1129         EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true));
1130         EXPECT_CALL(*service, PublishIncrementalFile(_)).WillOnce(Return(0));
1131         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
1132         auto ret = service->CmdPublishIncrementalFile(data, reply);
1133         EXPECT_EQ(ret, BError(BError::Codes::OK));
1134     } catch (...) {
1135         EXPECT_TRUE(false);
1136         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by PublishIncrementalFile.";
1137     }
1138     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100";
1139 }
1140 
1141 /**
1142  * @tc.number: SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_0100
1143  * @tc.name: SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_0100
1144  * @tc.desc: Test function of PublishSAIncrementalFile interface for SUCCESS.
1145  * @tc.size: MEDIUM
1146  * @tc.type: FUNC
1147  * @tc.level Level 1
1148  * @tc.require: I6F3GV
1149  */
1150 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_0100, testing::ext::TestSize.Level1)
1151 {
1152     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_0100";
1153     try {
1154         MessageParcel data;
1155         MessageParcel reply;
1156         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
1157         EXPECT_TRUE(service != nullptr);
1158         auto err = service->CmdPublishSAIncrementalFile(data, reply);
1159         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1160 
1161         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1));
1162         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1163         EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true));
1164         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
1165         EXPECT_CALL(*service, PublishSAIncrementalFile(_, _)).WillOnce(Return(0));
1166         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
1167         err = service->CmdPublishSAIncrementalFile(data, reply);
1168         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1169 
1170         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1));
1171         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1172         EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true));
1173         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0));
1174         EXPECT_CALL(*service, PublishSAIncrementalFile(_, _)).WillOnce(Return(0));
1175         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
1176         auto ret = service->CmdPublishSAIncrementalFile(data, reply);
1177         EXPECT_EQ(ret, BError(BError::Codes::OK));
1178     } catch (...) {
1179         EXPECT_TRUE(false);
1180         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by PublishSAIncrementalFile.";
1181     }
1182     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_0100";
1183 }
1184 
1185 /**
1186  * @tc.number: SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100
1187  * @tc.name: SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100
1188  * @tc.desc: Test function of AppIncrementalFileReady interface for FAILURE.
1189  * @tc.size: MEDIUM
1190  * @tc.type: FUNC
1191  * @tc.level Level 1
1192  * @tc.require: I6F3GV
1193  */
1194 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100, testing::ext::TestSize.Level1)
1195 {
1196     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100";
1197     try {
1198         MessageParcel data;
1199         MessageParcel reply;
1200         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
1201         EXPECT_TRUE(service != nullptr);
1202         auto err = service->CmdAppIncrementalFileReady(data, reply);
1203         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1204 
1205         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1206         EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
1207         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(-1));
1208         err = service->CmdAppIncrementalFileReady(data, reply);
1209         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1210 
1211         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1212         EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
1213         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(-1));
1214         err = service->CmdAppIncrementalFileReady(data, reply);
1215         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1216 
1217         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1218         EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
1219         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(1));
1220         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
1221         EXPECT_CALL(*service, AppIncrementalFileReady(_, _, _, _)).WillOnce(Return(0));
1222         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
1223         err = service->CmdAppIncrementalFileReady(data, reply);
1224         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1225     } catch (...) {
1226         EXPECT_TRUE(false);
1227         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppIncrementalFileReady.";
1228     }
1229     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100";
1230 }
1231 
1232 /**
1233  * @tc.number: SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101
1234  * @tc.name: SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101
1235  * @tc.desc: Test function of AppIncrementalFileReady interface for SUCCESS.
1236  * @tc.size: MEDIUM
1237  * @tc.type: FUNC
1238  * @tc.level Level 1
1239  * @tc.require: I6F3GV
1240  */
1241 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101, testing::ext::TestSize.Level1)
1242 {
1243     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101";
1244     try {
1245         MessageParcel data;
1246         MessageParcel reply;
1247 
1248         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1249         EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(false));
1250         EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0));
1251         EXPECT_TRUE(service != nullptr);
1252         EXPECT_CALL(*service, AppIncrementalFileReady(_, _, _, _)).WillOnce(Return(0));
1253         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
1254         auto ret = service->CmdAppIncrementalFileReady(data, reply);
1255         EXPECT_EQ(ret, BError(BError::Codes::OK));
1256     } catch (...) {
1257         EXPECT_TRUE(false);
1258         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppIncrementalFileReady.";
1259     }
1260     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101";
1261 }
1262 
1263 /**
1264  * @tc.number: SUB_backup_sa_ServiceStub_AppIncrementalDone_0100
1265  * @tc.name: SUB_backup_sa_ServiceStub_AppIncrementalDone_0100
1266  * @tc.desc: Test function of AppIncrementalDone interface for SUCCESS.
1267  * @tc.size: MEDIUM
1268  * @tc.type: FUNC
1269  * @tc.level Level 1
1270  * @tc.require: I6F3GV
1271  */
1272 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppIncrementalDone_0100, testing::ext::TestSize.Level1)
1273 {
1274     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppIncrementalDone_0100";
1275     try {
1276         MessageParcel data;
1277         MessageParcel reply;
1278         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
1279         EXPECT_TRUE(service != nullptr);
1280         auto err = service->CmdAppIncrementalDone(data, reply);
1281         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1282 
1283         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
1284         EXPECT_CALL(*service, AppIncrementalDone(_)).WillOnce(Return(0));
1285         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
1286         err = service->CmdAppIncrementalDone(data, reply);
1287         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1288 
1289         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
1290         EXPECT_CALL(*service, AppIncrementalDone(_)).WillOnce(Return(0));
1291         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
1292         auto ret = service->CmdAppIncrementalDone(data, reply);
1293         EXPECT_EQ(ret, BError(BError::Codes::OK));
1294     } catch (...) {
1295         EXPECT_TRUE(false);
1296         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppIncrementalDone.";
1297     }
1298     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppIncrementalDone_0100";
1299 }
1300 
1301 /**
1302  * @tc.number: SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_0100
1303  * @tc.name: SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_0100
1304  * @tc.desc: Test function of GetIncrementalFileHandle interface for SUCCESS.
1305  * @tc.size: MEDIUM
1306  * @tc.type: FUNC
1307  * @tc.level Level 1
1308  * @tc.require: I6F3GV
1309  */
1310 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_0100, testing::ext::TestSize.Level1)
1311 {
1312     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_0100";
1313     try {
1314         MessageParcel data;
1315         MessageParcel reply;
1316         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
1317         EXPECT_TRUE(service != nullptr);
1318         auto err = service->CmdGetIncrementalFileHandle(data, reply);
1319         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1320 
1321         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(false));
1322         err = service->CmdGetIncrementalFileHandle(data, reply);
1323         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1324 
1325         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1326         EXPECT_CALL(*service, GetIncrementalFileHandle(_, _)).WillOnce(Return(BError(BError::Codes::OK)));
1327         auto ret = service->CmdGetIncrementalFileHandle(data, reply);
1328         EXPECT_EQ(ret, BError(BError::Codes::OK));
1329     } catch (...) {
1330         EXPECT_TRUE(false);
1331         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by GetIncrementalFileHandle.";
1332     }
1333     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_0100";
1334 }
1335 
1336 /**
1337  * @tc.number: SUB_backup_sa_ServiceStub_CmdResultReport_0100
1338  * @tc.name: SUB_backup_sa_ServiceStub_CmdResultReport_0100
1339  * @tc.desc: Test function of CmdResultReport interface for FAILURE.
1340  * @tc.size: MEDIUM
1341  * @tc.type: FUNC
1342  * @tc.level Level 1
1343  * @tc.require: I6F3GV
1344  */
1345 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_CmdResultReport_0100, testing::ext::TestSize.Level1)
1346 {
1347     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_CmdResultReport_0100";
1348     try {
1349         MessageParcel data;
1350         MessageParcel reply;
1351         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
1352         EXPECT_TRUE(service != nullptr);
1353         auto err = service->CmdResultReport(data, reply);
1354         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1355 
1356         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1357         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
1358         err = service->CmdResultReport(data, reply);
1359         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1360 
1361         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1362         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
1363         err = service->CmdResultReport(data, reply);
1364         EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG));
1365 
1366         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1367         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
1368         EXPECT_CALL(*service, ServiceResultReport(_, _, _)).WillOnce(Return(BError(BError::Codes::OK)));
1369         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
1370         err = service->CmdResultReport(data, reply);
1371         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1372     } catch (...) {
1373         EXPECT_TRUE(false);
1374         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by CmdResultReport.";
1375     }
1376     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_CmdResultReport_0100";
1377 }
1378 
1379 /**
1380  * @tc.number: SUB_backup_sa_ServiceStub_CmdResultReport_0200
1381  * @tc.name: SUB_backup_sa_ServiceStub_CmdResultReport_0200
1382  * @tc.desc: Test function of GetIncrementalFileHandle interface for SUCCESS.
1383  * @tc.size: MEDIUM
1384  * @tc.type: FUNC
1385  * @tc.level Level 1
1386  * @tc.require: I6F3GV
1387  */
1388 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_CmdResultReport_0200, testing::ext::TestSize.Level1)
1389 {
1390     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_CmdResultReport_0200";
1391     try {
1392         MessageParcel data;
1393         MessageParcel reply;
1394         EXPECT_TRUE(service != nullptr);
1395         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1396         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true));
1397         EXPECT_CALL(*service, ServiceResultReport(_, _, _)).WillOnce(Return(BError(BError::Codes::OK)));
1398         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
1399         auto ret = service->CmdResultReport(data, reply);
1400         EXPECT_EQ(ret, BError(BError::Codes::OK));
1401     } catch (...) {
1402         EXPECT_TRUE(false);
1403         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by CmdResultReport.";
1404     }
1405     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_CmdResultReport_0200";
1406 }
1407 
1408 /**
1409  * @tc.number: SUB_backup_sa_ServiceStub_CmdUpdateSendRate_0100
1410  * @tc.name: SUB_backup_sa_ServiceStub_CmdUpdateSendRate_0100
1411  * @tc.desc: Test function of CmdUpdateSendRate interface for FAILURE.
1412  * @tc.size: MEDIUM
1413  * @tc.type: FUNC
1414  * @tc.level Level 1
1415  * @tc.require: I6F3GV
1416  */
1417 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_CmdUpdateSendRate_0100, testing::ext::TestSize.Level1)
1418 {
1419     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_CmdUpdateSendRate_0100";
1420     try {
1421         MessageParcel data;
1422         MessageParcel reply;
1423         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
1424         EXPECT_TRUE(service != nullptr);
1425         auto err = service->CmdUpdateSendRate(data, reply);
1426         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1427 
1428         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1429         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
1430         err = service->CmdUpdateSendRate(data, reply);
1431         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1432 
1433         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1434         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
1435         EXPECT_CALL(*service, UpdateSendRate(_, _, _)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG)));
1436         err = service->CmdUpdateSendRate(data, reply);
1437         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1438 
1439         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1440         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
1441         EXPECT_CALL(*service, UpdateSendRate(_, _, _)).WillOnce(Return(BError(BError::Codes::OK)));
1442         EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(false));
1443         err = service->CmdUpdateSendRate(data, reply);
1444         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1445 
1446         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
1447         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
1448         EXPECT_CALL(*service, UpdateSendRate(_, _, _)).WillOnce(Return(BError(BError::Codes::OK)));
1449         EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(true));
1450         err = service->CmdUpdateSendRate(data, reply);
1451         EXPECT_EQ(err, BError(BError::Codes::OK));
1452     } catch (...) {
1453         EXPECT_TRUE(false);
1454         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by CmdUpdateSendRate.";
1455     }
1456     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_CmdUpdateSendRate_0100";
1457 }
1458 
1459 /**
1460  * @tc.number: SUB_backup_sa_ServiceStub_CmdGetAppLocalListAndDoIncrementalBackup_0100
1461  * @tc.name: SUB_backup_sa_ServiceStub_CmdGetAppLocalListAndDoIncrementalBackup_0100
1462  * @tc.desc: Test function of CmdGetAppLocalListAndDoIncrementalBackup interface for FAILURE.
1463  * @tc.size: MEDIUM
1464  * @tc.type: FUNC
1465  * @tc.level Level 1
1466  * @tc.require: I6F3GV
1467  */
1468 HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_CmdGetAppLocalListAndDoIncrementalBackup_0100,
1469     testing::ext::TestSize.Level1)
1470 {
1471     GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_CmdGetAppLocalListAndDoIncrementalBackup_0100";
1472     try {
1473         MessageParcel data;
1474         MessageParcel reply;
1475         EXPECT_TRUE(service != nullptr);
1476         EXPECT_CALL(*service, GetAppLocalListAndDoIncrementalBackup()).WillOnce(Return(BError(BError::Codes::OK)));
1477         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
1478         auto err = service->CmdGetAppLocalListAndDoIncrementalBackup(data, reply);
1479         EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC));
1480 
1481         EXPECT_CALL(*service, GetAppLocalListAndDoIncrementalBackup()).WillOnce(Return(BError(BError::Codes::OK)));
1482         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
1483         err = service->CmdGetAppLocalListAndDoIncrementalBackup(data, reply);
1484         EXPECT_EQ(err, BError(BError::Codes::OK));
1485     } catch (...) {
1486         EXPECT_TRUE(false);
1487         GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by CmdGetAppLocalListAndDoIncrementalBackup.";
1488     }
1489     GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_CmdGetAppLocalListAndDoIncrementalBackup_0100";
1490 }
1491 } // namespace OHOS::FileManagement::Backup