1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 
19 #include "b_error/b_error.h"
20 #include "ext_extension_stub.h"
21 #include "message_parcel_mock.h"
22 
23 namespace OHOS::FileManagement::Backup {
24 using namespace std;
25 using namespace testing;
26 
27 class ExtExtensionStubMock : public ExtExtensionStub {
28 public:
29     MOCK_METHOD(UniqueFd, GetFileHandle, (const std::string &fileName, int32_t &errCode));
30     MOCK_METHOD(ErrCode, HandleClear, ());
31     MOCK_METHOD(ErrCode, HandleBackup, (bool isClearData));
32     MOCK_METHOD(ErrCode, PublishFile, (const std::string &fileName));
33     MOCK_METHOD(ErrCode, HandleRestore, (bool isClearData));
34     MOCK_METHOD(ErrCode, GetIncrementalFileHandle, (const std::string &fileName));
35     MOCK_METHOD(ErrCode, PublishIncrementalFile, (const std::string &fileName));
36     MOCK_METHOD(ErrCode, HandleIncrementalBackup, (UniqueFd incrementalFd, UniqueFd manifestFd));
37     MOCK_METHOD(ErrCode, IncrementalOnBackup, (bool isClearData));
38     MOCK_METHOD((std::tuple<UniqueFd, UniqueFd>), GetIncrementalBackupFileHandle, ());
39     MOCK_METHOD(ErrCode, GetBackupInfo, (std::string &result));
40     MOCK_METHOD(ErrCode, UpdateFdSendRate, (std::string &bundleName, int32_t sendRate));
41     MOCK_METHOD(ErrCode, User0OnBackup, ());
42 };
43 
44 class ExtExtensionStubTest : public testing::Test {
45 public:
46     //所有测试用例执行之前执行
47     static void SetUpTestCase(void);
48     //所有测试用例执行之后执行
49     static void TearDownTestCase(void);
50     //每次测试用例执行之前执行
SetUp()51     void SetUp() {};
52     //每次测试用例执行之后执行
TearDown()53     void TearDown() {};
54 public:
55     static inline shared_ptr<ExtExtensionStubMock> stub = nullptr;
56     static inline shared_ptr<MessageParcelMock> messageParcelMock = nullptr;
57 };
58 
SetUpTestCase()59 void ExtExtensionStubTest::SetUpTestCase()
60 {
61     stub = make_shared<ExtExtensionStubMock>();
62     messageParcelMock = make_shared<MessageParcelMock>();
63     MessageParcelMock::messageParcel = messageParcelMock;
64 }
65 
TearDownTestCase()66 void ExtExtensionStubTest::TearDownTestCase()
67 {
68     stub = nullptr;
69     MessageParcelMock::messageParcel = nullptr;
70     messageParcelMock = nullptr;
71 }
72 
73 /**
74  * @tc.number: SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0100
75  * @tc.name: SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0100
76  * @tc.desc: 测试 OnRemoteRequest 各个分支成功与失败
77  * @tc.size: MEDIUM
78  * @tc.type: FUNC
79  * @tc.level Level 1
80  * @tc.require: issuesI9QWK5
81  */
82 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0100, testing::ext::TestSize.Level1)
83 {
84     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0100";
85     try {
86         uint32_t code = 0;
87         MessageParcel data;
88         MessageParcel reply;
89         MessageOption option;
90         EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(u16string()));
91         EXPECT_TRUE(stub != nullptr);
92         auto err = stub->OnRemoteRequest(code, data, reply, option);
93         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
94 
95         const std::u16string descriptor = ExtExtensionStub::GetDescriptor();
96         EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(descriptor));
97         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
98         err = stub->OnRemoteRequest(static_cast<uint32_t>(IExtensionInterfaceCode::CMD_GET_FILE_HANDLE),
99             data, reply, option);
100         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
101 
102         EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(descriptor));
103         auto ret = stub->OnRemoteRequest(-1, data, reply, option);
104         EXPECT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR);
105     } catch (...) {
106         EXPECT_TRUE(false);
107         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by OnRemoteRequest.";
108     }
109     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0100";
110 }
111 
112 /**
113  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100
114  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100
115  * @tc.desc: 测试 CmdGetFileHandle 各个分支成功与失败
116  * @tc.size: MEDIUM
117  * @tc.type: FUNC
118  * @tc.level Level 1
119  * @tc.require: issuesI9QWK5
120  */
121 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100, testing::ext::TestSize.Level1)
122 {
123     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100";
124     try {
125         MessageParcel data;
126         MessageParcel reply;
127         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
128         EXPECT_TRUE(stub != nullptr);
129         auto err = stub->CmdGetFileHandle(data, reply);
130         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
131 
132         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
133         EXPECT_CALL(*stub, GetFileHandle(_, _)).WillOnce(Return(UniqueFd(-1)));
134         EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(true));
135         err = stub->CmdGetFileHandle(data, reply);
136         EXPECT_EQ(err, BError(BError::Codes::OK));
137 
138         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
139         EXPECT_CALL(*stub, GetFileHandle(_, _)).WillOnce(Return(UniqueFd(0)));
140         EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(true));
141         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false));
142         err = stub->CmdGetFileHandle(data, reply);
143         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
144 
145         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
146         EXPECT_CALL(*stub, GetFileHandle(_, _)).WillOnce(Return(UniqueFd(0)));
147         EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(true));
148         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true));
149         err = stub->CmdGetFileHandle(data, reply);
150         EXPECT_EQ(err, BError(BError::Codes::OK));
151     } catch (...) {
152         EXPECT_TRUE(false);
153         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetFileHandle.";
154     }
155     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100";
156 }
157 
158 /**
159  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100
160  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100
161  * @tc.desc: 测试 CmdHandleClear 各个分支成功与失败
162  * @tc.size: MEDIUM
163  * @tc.type: FUNC
164  * @tc.level Level 1
165  * @tc.require: issuesI9QWK5
166  */
167 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100, testing::ext::TestSize.Level1)
168 {
169     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100";
170     try {
171         MessageParcel data;
172         MessageParcel reply;
173         EXPECT_CALL(*stub, HandleClear()).WillOnce(Return(0));
174         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
175         EXPECT_TRUE(stub != nullptr);
176         auto err = stub->CmdHandleClear(data, reply);
177         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
178 
179         EXPECT_CALL(*stub, HandleClear()).WillOnce(Return(0));
180         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
181         err = stub->CmdHandleClear(data, reply);
182         EXPECT_EQ(err, BError(BError::Codes::OK));
183     } catch (...) {
184         EXPECT_TRUE(false);
185         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleClear.";
186     }
187     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100";
188 }
189 
190 /**
191  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100
192  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100
193  * @tc.desc: 测试 CmdHandleBackup 各个分支成功与失败
194  * @tc.size: MEDIUM
195  * @tc.type: FUNC
196  * @tc.level Level 1
197  * @tc.require: issuesI9QWK5
198  */
199 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100, testing::ext::TestSize.Level1)
200 {
201     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100";
202     try {
203         MessageParcel data;
204         MessageParcel reply;
205         EXPECT_CALL(*stub, HandleBackup(_)).WillOnce(Return(0));
206         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
207         EXPECT_TRUE(stub != nullptr);
208         auto err = stub->CmdHandleBackup(data, reply);
209         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
210 
211         EXPECT_CALL(*stub, HandleBackup(_)).WillOnce(Return(0));
212         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
213         err = stub->CmdHandleBackup(data, reply);
214         EXPECT_EQ(err, BError(BError::Codes::OK));
215     } catch (...) {
216         EXPECT_TRUE(false);
217         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleBackup.";
218     }
219     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100";
220 }
221 
222 /**
223  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100
224  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100
225  * @tc.desc: 测试 CmdPublishFile 各个分支成功与失败
226  * @tc.size: MEDIUM
227  * @tc.type: FUNC
228  * @tc.level Level 1
229  * @tc.require: issuesI9QWK5
230  */
231 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100, testing::ext::TestSize.Level1)
232 {
233     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100";
234     try {
235         MessageParcel data;
236         MessageParcel reply;
237         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
238         EXPECT_TRUE(stub != nullptr);
239         auto err = stub->CmdPublishFile(data, reply);
240         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
241 
242         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
243         EXPECT_CALL(*stub, PublishFile(_)).WillOnce(Return(0));
244         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
245         err = stub->CmdPublishFile(data, reply);
246         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
247 
248         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
249         EXPECT_CALL(*stub, PublishFile(_)).WillOnce(Return(0));
250         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
251         err = stub->CmdPublishFile(data, reply);
252         EXPECT_EQ(err, BError(BError::Codes::OK));
253     } catch (...) {
254         EXPECT_TRUE(false);
255         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdPublishFile.";
256     }
257     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100";
258 }
259 
260 /**
261  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100
262  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100
263  * @tc.desc: 测试 CmdHandleRestore 各个分支成功与失败
264  * @tc.size: MEDIUM
265  * @tc.type: FUNC
266  * @tc.level Level 1
267  * @tc.require: issuesI9QWK5
268  */
269 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100, testing::ext::TestSize.Level1)
270 {
271     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100";
272     try {
273         MessageParcel data;
274         MessageParcel reply;
275         EXPECT_CALL(*stub, HandleRestore(_)).WillOnce(Return(0));
276         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
277         EXPECT_TRUE(stub != nullptr);
278         auto err = stub->CmdHandleRestore(data, reply);
279         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
280 
281         EXPECT_CALL(*stub, HandleRestore(_)).WillOnce(Return(0));
282         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
283         err = stub->CmdHandleRestore(data, reply);
284         EXPECT_EQ(err, BError(BError::Codes::OK));
285     } catch (...) {
286         EXPECT_TRUE(false);
287         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleRestore.";
288     }
289     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100";
290 }
291 
292 /**
293  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100
294  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100
295  * @tc.desc: 测试 CmdGetIncrementalFileHandle 各个分支成功与失败
296  * @tc.size: MEDIUM
297  * @tc.type: FUNC
298  * @tc.level Level 1
299  * @tc.require: issuesI9QWK5
300  */
301 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100,
302     testing::ext::TestSize.Level1)
303 {
304     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100";
305     try {
306         MessageParcel data;
307         MessageParcel reply;
308         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
309         EXPECT_TRUE(stub != nullptr);
310         auto err = stub->CmdGetIncrementalFileHandle(data, reply);
311         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
312 
313         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
314         EXPECT_CALL(*stub, GetIncrementalFileHandle(_)).WillOnce(Return(0));
315         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
316         err = stub->CmdGetIncrementalFileHandle(data, reply);
317         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
318 
319         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
320         EXPECT_CALL(*stub, GetIncrementalFileHandle(_)).WillOnce(Return(0));
321         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
322         err = stub->CmdGetIncrementalFileHandle(data, reply);
323         EXPECT_EQ(err, BError(BError::Codes::OK));
324     } catch (...) {
325         EXPECT_TRUE(false);
326         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetIncrementalFileHandle.";
327     }
328     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100";
329 }
330 
331 /**
332  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100
333  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100
334  * @tc.desc: 测试 CmdPublishIncrementalFile 各个分支成功与失败
335  * @tc.size: MEDIUM
336  * @tc.type: FUNC
337  * @tc.level Level 1
338  * @tc.require: issuesI9QWK5
339  */
340 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100,
341     testing::ext::TestSize.Level1)
342 {
343     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100";
344     try {
345         MessageParcel data;
346         MessageParcel reply;
347         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
348         EXPECT_TRUE(stub != nullptr);
349         auto err = stub->CmdPublishIncrementalFile(data, reply);
350         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
351 
352         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
353         EXPECT_CALL(*stub, PublishIncrementalFile(_)).WillOnce(Return(0));
354         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
355         err = stub->CmdPublishIncrementalFile(data, reply);
356         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
357 
358         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
359         EXPECT_CALL(*stub, PublishIncrementalFile(_)).WillOnce(Return(0));
360         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
361         err = stub->CmdPublishIncrementalFile(data, reply);
362         EXPECT_EQ(err, BError(BError::Codes::OK));
363     } catch (...) {
364         EXPECT_TRUE(false);
365         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdPublishIncrementalFile.";
366     }
367     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100";
368 }
369 
370 /**
371  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100
372  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100
373  * @tc.desc: 测试 CmdHandleIncrementalBackup 各个分支成功与失败
374  * @tc.size: MEDIUM
375  * @tc.type: FUNC
376  * @tc.level Level 1
377  * @tc.require: issuesI9QWK5
378  */
379 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100,
380     testing::ext::TestSize.Level1)
381 {
382     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100";
383     try {
384         MessageParcel data;
385         MessageParcel reply;
386         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(0));
387         EXPECT_CALL(*stub, HandleIncrementalBackup(_, _)).WillOnce(Return(0));
388         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
389         EXPECT_TRUE(stub != nullptr);
390         auto err = stub->CmdHandleIncrementalBackup(data, reply);
391         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
392 
393         EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(0));
394         EXPECT_CALL(*stub, HandleIncrementalBackup(_, _)).WillOnce(Return(0));
395         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
396         err = stub->CmdHandleIncrementalBackup(data, reply);
397         EXPECT_EQ(err, BError(BError::Codes::OK));
398     } catch (...) {
399         EXPECT_TRUE(false);
400         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleIncrementalBackup.";
401     }
402     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100";
403 }
404 
405 /**
406  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100
407  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100
408  * @tc.desc: 测试 CmdIncrementalOnBackup 各个分支成功与失败
409  * @tc.size: MEDIUM
410  * @tc.type: FUNC
411  * @tc.level Level 1
412  * @tc.require: issuesI9QWK5
413  */
414 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100,
415     testing::ext::TestSize.Level1)
416 {
417     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100";
418     try {
419         MessageParcel data;
420         MessageParcel reply;
421         EXPECT_CALL(*stub, IncrementalOnBackup(_)).WillOnce(Return(0));
422         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
423         EXPECT_TRUE(stub != nullptr);
424         auto err = stub->CmdIncrementalOnBackup(data, reply);
425         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
426 
427         EXPECT_CALL(*stub, IncrementalOnBackup(_)).WillOnce(Return(0));
428         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
429         err = stub->CmdIncrementalOnBackup(data, reply);
430         EXPECT_EQ(err, BError(BError::Codes::OK));
431     } catch (...) {
432         EXPECT_TRUE(false);
433         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdIncrementalOnBackup.";
434     }
435     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100";
436 }
437 
438 /**
439  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100
440  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100
441  * @tc.desc: 测试 CmdGetIncrementalBackupFileHandle 各个分支成功与失败
442  * @tc.size: MEDIUM
443  * @tc.type: FUNC
444  * @tc.level Level 1
445  * @tc.require: issuesI9QWK5
446  */
447 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100,
448     testing::ext::TestSize.Level1)
449 {
450     GTEST_LOG_(INFO) <<
451         "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100";
452     try {
453         MessageParcel data;
454         MessageParcel reply;
455         EXPECT_CALL(*stub, GetIncrementalBackupFileHandle())
456             .WillOnce(Return(std::tuple<UniqueFd, UniqueFd>(UniqueFd(-1), UniqueFd(-1))));
457         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false));
458         EXPECT_TRUE(stub != nullptr);
459         auto err = stub->CmdGetIncrementalBackupFileHandle(data, reply);
460         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
461 
462         EXPECT_CALL(*stub, GetIncrementalBackupFileHandle())
463             .WillOnce(Return(std::tuple<UniqueFd, UniqueFd>(UniqueFd(-1), UniqueFd(-1))));
464         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(false));
465         err = stub->CmdGetIncrementalBackupFileHandle(data, reply);
466         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
467 
468         EXPECT_CALL(*stub, GetIncrementalBackupFileHandle())
469             .WillOnce(Return(std::tuple<UniqueFd, UniqueFd>(UniqueFd(-1), UniqueFd(-1))));
470         EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
471         err = stub->CmdGetIncrementalBackupFileHandle(data, reply);
472         EXPECT_EQ(err, BError(BError::Codes::OK));
473     } catch (...) {
474         EXPECT_TRUE(false);
475         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetIncrementalBackupFileHandle.";
476     }
477     GTEST_LOG_(INFO) <<
478         "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100";
479 }
480 
481 /**
482  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100
483  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100
484  * @tc.desc: 测试 CmdGetBackupInfo 各个分支成功与失败
485  * @tc.size: MEDIUM
486  * @tc.type: FUNC
487  * @tc.level Level 1
488  * @tc.require: issuesI9QWK5
489  */
490 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100, testing::ext::TestSize.Level1)
491 {
492     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100";
493     try {
494         MessageParcel data;
495         MessageParcel reply;
496         EXPECT_CALL(*stub, GetBackupInfo(_)).WillOnce(Return(0));
497         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
498         EXPECT_TRUE(stub != nullptr);
499         auto err = stub->CmdGetBackupInfo(data, reply);
500         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
501 
502         EXPECT_CALL(*stub, GetBackupInfo(_)).WillOnce(Return(0));
503         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
504         EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(false));
505         err = stub->CmdGetBackupInfo(data, reply);
506         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
507 
508         EXPECT_CALL(*stub, GetBackupInfo(_)).WillOnce(Return(0));
509         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
510         EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true));
511         err = stub->CmdGetBackupInfo(data, reply);
512         EXPECT_EQ(err, BError(BError::Codes::OK));
513     } catch (...) {
514         EXPECT_TRUE(false);
515         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetBackupInfo.";
516     }
517     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100";
518 }
519 
520 /**
521  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100
522  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100
523  * @tc.desc: 测试 CmdUpdateSendRate 各个分支成功与失败
524  * @tc.size: MEDIUM
525  * @tc.type: FUNC
526  * @tc.level Level 1
527  * @tc.require: issuesI9QWK5
528  */
529 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100, testing::ext::TestSize.Level1)
530 {
531     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100";
532     try {
533         MessageParcel data;
534         MessageParcel reply;
535         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
536         EXPECT_TRUE(stub != nullptr);
537         auto err = stub->CmdUpdateFdSendRate(data, reply);
538         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
539 
540         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
541         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
542         err = stub->CmdUpdateFdSendRate(data, reply);
543         EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
544 
545         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
546         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
547         EXPECT_CALL(*stub, UpdateFdSendRate(_, _)).WillOnce(Return(0));
548         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
549         err = stub->CmdUpdateFdSendRate(data, reply);
550         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
551 
552         EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
553         EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
554         EXPECT_CALL(*stub, UpdateFdSendRate(_, _)).WillOnce(Return(0));
555         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
556         err = stub->CmdUpdateFdSendRate(data, reply);
557         EXPECT_EQ(err, BError(BError::Codes::OK));
558     } catch (...) {
559         EXPECT_TRUE(false);
560         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdUpdateSendRate.";
561     }
562     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100";
563 }
564 
565 /**
566  * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdUser0_0100
567  * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdUser0_0100
568  * @tc.desc: 测试 CmdHandleUser0Backup 各个分支成功与失败
569  * @tc.size: MEDIUM
570  * @tc.type: FUNC
571  * @tc.level Level 1
572  * @tc.require: issues
573  */
574 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdUser0_0100, testing::ext::TestSize.Level1)
575 {
576     GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdUser0_0100";
577     try {
578         MessageParcel data;
579         MessageParcel reply;
580         EXPECT_CALL(*stub, User0OnBackup()).WillOnce(Return(0));
581         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
582         EXPECT_TRUE(stub != nullptr);
583         auto err = stub->CmdHandleUser0Backup(data, reply);
584         EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
585 
586         EXPECT_CALL(*stub, User0OnBackup()).WillOnce(Return(0));
587         EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
588         err = stub->CmdHandleUser0Backup(data, reply);
589         EXPECT_EQ(err, BError(BError::Codes::OK));
590     } catch (...) {
591         EXPECT_TRUE(false);
592         GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleClear.";
593     }
594     GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdUser0_0100";
595 }
596 } // namespace OHOS::FileManagement::Backup