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