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((std::tuple<ErrCode, UniqueFd, UniqueFd>), 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 ASSERT_TRUE(stub != nullptr);
87 uint32_t code = 0;
88 MessageParcel data;
89 MessageParcel reply;
90 MessageOption option;
91 EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(u16string()));
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 ASSERT_TRUE(stub != nullptr);
126 MessageParcel data;
127 MessageParcel reply;
128 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
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 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
136 err = stub->CmdGetFileHandle(data, reply);
137 EXPECT_EQ(err, BError(BError::Codes::OK));
138
139 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
140 EXPECT_CALL(*stub, GetFileHandle(_, _)).WillOnce(Return(UniqueFd(0)));
141 EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(true));
142 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
143 EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false));
144 err = stub->CmdGetFileHandle(data, reply);
145 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
146
147 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
148 EXPECT_CALL(*stub, GetFileHandle(_, _)).WillOnce(Return(UniqueFd(0)));
149 EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(true));
150 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
151 EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true));
152 err = stub->CmdGetFileHandle(data, reply);
153 EXPECT_EQ(err, BError(BError::Codes::OK));
154 } catch (...) {
155 EXPECT_TRUE(false);
156 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetFileHandle.";
157 }
158 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100";
159 }
160
161 /**
162 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100
163 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100
164 * @tc.desc: 测试 CmdHandleClear 各个分支成功与失败
165 * @tc.size: MEDIUM
166 * @tc.type: FUNC
167 * @tc.level Level 1
168 * @tc.require: issuesI9QWK5
169 */
170 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100, testing::ext::TestSize.Level1)
171 {
172 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100";
173 try {
174 ASSERT_TRUE(stub != nullptr);
175 MessageParcel data;
176 MessageParcel reply;
177 EXPECT_CALL(*stub, HandleClear()).WillOnce(Return(0));
178 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
179 auto err = stub->CmdHandleClear(data, reply);
180 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
181
182 EXPECT_CALL(*stub, HandleClear()).WillOnce(Return(0));
183 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
184 err = stub->CmdHandleClear(data, reply);
185 EXPECT_EQ(err, BError(BError::Codes::OK));
186 } catch (...) {
187 EXPECT_TRUE(false);
188 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleClear.";
189 }
190 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100";
191 }
192
193 /**
194 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100
195 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100
196 * @tc.desc: 测试 CmdHandleBackup 各个分支成功与失败
197 * @tc.size: MEDIUM
198 * @tc.type: FUNC
199 * @tc.level Level 1
200 * @tc.require: issuesI9QWK5
201 */
202 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100, testing::ext::TestSize.Level1)
203 {
204 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100";
205 try {
206 ASSERT_TRUE(stub != nullptr);
207 MessageParcel data;
208 MessageParcel reply;
209 EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
210 EXPECT_CALL(*stub, HandleBackup(_)).WillOnce(Return(0));
211 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
212 auto err = stub->CmdHandleBackup(data, reply);
213 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
214
215 EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
216 EXPECT_CALL(*stub, HandleBackup(_)).WillOnce(Return(0));
217 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
218 err = stub->CmdHandleBackup(data, reply);
219 EXPECT_EQ(err, BError(BError::Codes::OK));
220 } catch (...) {
221 EXPECT_TRUE(false);
222 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleBackup.";
223 }
224 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100";
225 }
226
227 /**
228 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100
229 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100
230 * @tc.desc: 测试 CmdPublishFile 各个分支成功与失败
231 * @tc.size: MEDIUM
232 * @tc.type: FUNC
233 * @tc.level Level 1
234 * @tc.require: issuesI9QWK5
235 */
236 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100, testing::ext::TestSize.Level1)
237 {
238 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100";
239 try {
240 ASSERT_TRUE(stub != nullptr);
241 MessageParcel data;
242 MessageParcel reply;
243 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
244 auto err = stub->CmdPublishFile(data, reply);
245 EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
246
247 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
248 EXPECT_CALL(*stub, PublishFile(_)).WillOnce(Return(0));
249 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
250 err = stub->CmdPublishFile(data, reply);
251 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
252
253 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
254 EXPECT_CALL(*stub, PublishFile(_)).WillOnce(Return(0));
255 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
256 err = stub->CmdPublishFile(data, reply);
257 EXPECT_EQ(err, BError(BError::Codes::OK));
258 } catch (...) {
259 EXPECT_TRUE(false);
260 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdPublishFile.";
261 }
262 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100";
263 }
264
265 /**
266 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100
267 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100
268 * @tc.desc: 测试 CmdHandleRestore 各个分支成功与失败
269 * @tc.size: MEDIUM
270 * @tc.type: FUNC
271 * @tc.level Level 1
272 * @tc.require: issuesI9QWK5
273 */
274 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100, testing::ext::TestSize.Level1)
275 {
276 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100";
277 try {
278 ASSERT_TRUE(stub != nullptr);
279 MessageParcel data;
280 MessageParcel reply;
281 EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
282 EXPECT_CALL(*stub, HandleRestore(_)).WillOnce(Return(0));
283 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
284 auto err = stub->CmdHandleRestore(data, reply);
285 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
286
287 EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
288 EXPECT_CALL(*stub, HandleRestore(_)).WillOnce(Return(0));
289 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
290 err = stub->CmdHandleRestore(data, reply);
291 EXPECT_EQ(err, BError(BError::Codes::OK));
292 } catch (...) {
293 EXPECT_TRUE(false);
294 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleRestore.";
295 }
296 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100";
297 }
298
299 /**
300 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100
301 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100
302 * @tc.desc: 测试 CmdGetIncrementalFileHandle 各个分支成功与失败
303 * @tc.size: MEDIUM
304 * @tc.type: FUNC
305 * @tc.level Level 1
306 * @tc.require: issuesI9QWK5
307 */
308 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100,
309 testing::ext::TestSize.Level1)
310 {
311 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100";
312 try {
313 ASSERT_TRUE(stub != nullptr);
314 MessageParcel data;
315 MessageParcel reply;
316 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
317 auto err = stub->CmdGetIncrementalFileHandle(data, reply);
318 EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
319
320 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
321 EXPECT_CALL(*stub, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1))));
322 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
323 err = stub->CmdGetIncrementalFileHandle(data, reply);
324 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
325
326 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
327 EXPECT_CALL(*stub, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1))));
328 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
329 EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
330 err = stub->CmdGetIncrementalFileHandle(data, reply);
331 EXPECT_EQ(err, BError(BError::Codes::OK));
332 } catch (...) {
333 EXPECT_TRUE(false);
334 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetIncrementalFileHandle.";
335 }
336 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100";
337 }
338
339 /**
340 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100
341 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100
342 * @tc.desc: 测试 CmdPublishIncrementalFile 各个分支成功与失败
343 * @tc.size: MEDIUM
344 * @tc.type: FUNC
345 * @tc.level Level 1
346 * @tc.require: issuesI9QWK5
347 */
348 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100,
349 testing::ext::TestSize.Level1)
350 {
351 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100";
352 try {
353 ASSERT_TRUE(stub != nullptr);
354 MessageParcel data;
355 MessageParcel reply;
356 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
357 auto err = stub->CmdPublishIncrementalFile(data, reply);
358 EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
359
360 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
361 EXPECT_CALL(*stub, PublishIncrementalFile(_)).WillOnce(Return(0));
362 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
363 err = stub->CmdPublishIncrementalFile(data, reply);
364 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
365
366 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
367 EXPECT_CALL(*stub, PublishIncrementalFile(_)).WillOnce(Return(0));
368 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
369 err = stub->CmdPublishIncrementalFile(data, reply);
370 EXPECT_EQ(err, BError(BError::Codes::OK));
371 } catch (...) {
372 EXPECT_TRUE(false);
373 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdPublishIncrementalFile.";
374 }
375 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100";
376 }
377
378 /**
379 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100
380 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100
381 * @tc.desc: 测试 CmdHandleIncrementalBackup 各个分支成功与失败
382 * @tc.size: MEDIUM
383 * @tc.type: FUNC
384 * @tc.level Level 1
385 * @tc.require: issuesI9QWK5
386 */
387 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100,
388 testing::ext::TestSize.Level1)
389 {
390 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100";
391 try {
392 ASSERT_TRUE(stub != nullptr);
393 MessageParcel data;
394 MessageParcel reply;
395 EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(0));
396 EXPECT_CALL(*stub, HandleIncrementalBackup(_, _)).WillOnce(Return(0));
397 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
398 auto err = stub->CmdHandleIncrementalBackup(data, reply);
399 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
400
401 EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(0));
402 EXPECT_CALL(*stub, HandleIncrementalBackup(_, _)).WillOnce(Return(0));
403 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
404 err = stub->CmdHandleIncrementalBackup(data, reply);
405 EXPECT_EQ(err, BError(BError::Codes::OK));
406 } catch (...) {
407 EXPECT_TRUE(false);
408 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleIncrementalBackup.";
409 }
410 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100";
411 }
412
413 /**
414 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100
415 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100
416 * @tc.desc: 测试 CmdIncrementalOnBackup 各个分支成功与失败
417 * @tc.size: MEDIUM
418 * @tc.type: FUNC
419 * @tc.level Level 1
420 * @tc.require: issuesI9QWK5
421 */
422 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100,
423 testing::ext::TestSize.Level1)
424 {
425 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100";
426 try {
427 ASSERT_TRUE(stub != nullptr);
428 MessageParcel data;
429 MessageParcel reply;
430 EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
431 EXPECT_CALL(*stub, IncrementalOnBackup(_)).WillOnce(Return(0));
432 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
433 auto err = stub->CmdIncrementalOnBackup(data, reply);
434 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
435
436 EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true));
437 EXPECT_CALL(*stub, IncrementalOnBackup(_)).WillOnce(Return(0));
438 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
439 err = stub->CmdIncrementalOnBackup(data, reply);
440 EXPECT_EQ(err, BError(BError::Codes::OK));
441 } catch (...) {
442 EXPECT_TRUE(false);
443 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdIncrementalOnBackup.";
444 }
445 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100";
446 }
447
448 /**
449 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100
450 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100
451 * @tc.desc: 测试 CmdGetIncrementalBackupFileHandle 各个分支成功与失败
452 * @tc.size: MEDIUM
453 * @tc.type: FUNC
454 * @tc.level Level 1
455 * @tc.require: issuesI9QWK5
456 */
457 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100,
458 testing::ext::TestSize.Level1)
459 {
460 GTEST_LOG_(INFO) <<
461 "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100";
462 try {
463 ASSERT_TRUE(stub != nullptr);
464 MessageParcel data;
465 MessageParcel reply;
466 EXPECT_CALL(*stub, GetIncrementalBackupFileHandle())
467 .WillOnce(Return(std::tuple<UniqueFd, UniqueFd>(UniqueFd(-1), UniqueFd(-1))));
468 EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false));
469 auto err = stub->CmdGetIncrementalBackupFileHandle(data, reply);
470 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
471
472 EXPECT_CALL(*stub, GetIncrementalBackupFileHandle())
473 .WillOnce(Return(std::tuple<UniqueFd, UniqueFd>(UniqueFd(-1), UniqueFd(-1))));
474 EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(false));
475 err = stub->CmdGetIncrementalBackupFileHandle(data, reply);
476 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
477
478 EXPECT_CALL(*stub, GetIncrementalBackupFileHandle())
479 .WillOnce(Return(std::tuple<UniqueFd, UniqueFd>(UniqueFd(-1), UniqueFd(-1))));
480 EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
481 err = stub->CmdGetIncrementalBackupFileHandle(data, reply);
482 EXPECT_EQ(err, BError(BError::Codes::OK));
483 } catch (...) {
484 EXPECT_TRUE(false);
485 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetIncrementalBackupFileHandle.";
486 }
487 GTEST_LOG_(INFO) <<
488 "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100";
489 }
490
491 /**
492 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100
493 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100
494 * @tc.desc: 测试 CmdGetBackupInfo 各个分支成功与失败
495 * @tc.size: MEDIUM
496 * @tc.type: FUNC
497 * @tc.level Level 1
498 * @tc.require: issuesI9QWK5
499 */
500 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100, testing::ext::TestSize.Level1)
501 {
502 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100";
503 try {
504 ASSERT_TRUE(stub != nullptr);
505 MessageParcel data;
506 MessageParcel reply;
507 EXPECT_CALL(*stub, GetBackupInfo(_)).WillOnce(Return(0));
508 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
509 auto err = stub->CmdGetBackupInfo(data, reply);
510 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
511
512 EXPECT_CALL(*stub, GetBackupInfo(_)).WillOnce(Return(0));
513 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
514 EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(false));
515 err = stub->CmdGetBackupInfo(data, reply);
516 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
517
518 EXPECT_CALL(*stub, GetBackupInfo(_)).WillOnce(Return(0));
519 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
520 EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true));
521 err = stub->CmdGetBackupInfo(data, reply);
522 EXPECT_EQ(err, BError(BError::Codes::OK));
523 } catch (...) {
524 EXPECT_TRUE(false);
525 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetBackupInfo.";
526 }
527 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100";
528 }
529
530 /**
531 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100
532 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100
533 * @tc.desc: 测试 CmdUpdateSendRate 各个分支成功与失败
534 * @tc.size: MEDIUM
535 * @tc.type: FUNC
536 * @tc.level Level 1
537 * @tc.require: issuesI9QWK5
538 */
539 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100, testing::ext::TestSize.Level1)
540 {
541 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100";
542 try {
543 ASSERT_TRUE(stub != nullptr);
544 MessageParcel data;
545 MessageParcel reply;
546 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false));
547 auto err = stub->CmdUpdateFdSendRate(data, reply);
548 EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
549
550 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
551 EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false));
552 err = stub->CmdUpdateFdSendRate(data, reply);
553 EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG));
554
555 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
556 EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
557 EXPECT_CALL(*stub, UpdateFdSendRate(_, _)).WillOnce(Return(0));
558 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
559 err = stub->CmdUpdateFdSendRate(data, reply);
560 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
561
562 EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true));
563 EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true));
564 EXPECT_CALL(*stub, UpdateFdSendRate(_, _)).WillOnce(Return(0));
565 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
566 err = stub->CmdUpdateFdSendRate(data, reply);
567 EXPECT_EQ(err, BError(BError::Codes::OK));
568 } catch (...) {
569 EXPECT_TRUE(false);
570 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdUpdateSendRate.";
571 }
572 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100";
573 }
574
575 /**
576 * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdUser0_0100
577 * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdUser0_0100
578 * @tc.desc: 测试 CmdHandleUser0Backup 各个分支成功与失败
579 * @tc.size: MEDIUM
580 * @tc.type: FUNC
581 * @tc.level Level 1
582 * @tc.require: issues
583 */
584 HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdUser0_0100, testing::ext::TestSize.Level1)
585 {
586 GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdUser0_0100";
587 try {
588 MessageParcel data;
589 MessageParcel reply;
590 EXPECT_CALL(*stub, User0OnBackup()).WillOnce(Return(0));
591 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false));
592 EXPECT_TRUE(stub != nullptr);
593 auto err = stub->CmdHandleUser0Backup(data, reply);
594 EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC));
595
596 EXPECT_CALL(*stub, User0OnBackup()).WillOnce(Return(0));
597 EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true));
598 err = stub->CmdHandleUser0Backup(data, reply);
599 EXPECT_EQ(err, BError(BError::Codes::OK));
600 } catch (...) {
601 EXPECT_TRUE(false);
602 GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleClear.";
603 }
604 GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdUser0_0100";
605 }
606 } // namespace OHOS::FileManagement::Backup