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 <cstdio>
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20 
21 #include "b_file_info.h"
22 #include "i_service_mock.h"
23 #include "iremote_object_mock.h"
24 #include "iservice_registry.h"
25 #include "service_proxy.h"
26 #include "service_reverse_mock.h"
27 #include "unique_fd.h"
28 #include "utils_mock_global_variable.h"
29 
30 namespace OHOS::FileManagement::Backup {
31 using namespace std;
32 using namespace testing;
33 
34 namespace {
35 const string FILE_NAME = "1.tar";
36 constexpr int32_t SERVICE_ID = 5203;
37 } // namespace
38 
39 class ServiceProxyTest : public testing::Test {
40 public:
SetUpTestCase(void)41     static void SetUpTestCase(void) {};
TearDownTestCase()42     static void TearDownTestCase() {};
43     void SetUp() override;
44     void TearDown() override;
45 
46     shared_ptr<ServiceProxy> proxy_ = nullptr;
47     sptr<IServiceMock> mock_ = nullptr;
48     sptr<ServiceReverseMock> remote_ = nullptr;
49 };
50 
SetUp()51 void ServiceProxyTest::SetUp()
52 {
53     mock_ = sptr(new IServiceMock());
54     proxy_ = make_shared<ServiceProxy>(mock_);
55     remote_ = sptr(new ServiceReverseMock());
56 }
57 
TearDown()58 void ServiceProxyTest::TearDown()
59 {
60     proxy_ = nullptr;
61     mock_ = nullptr;
62     remote_ = nullptr;
63 }
64 
65 /**
66  * @tc.number: SUB_Service_proxy_InitRestoreSession_0100
67  * @tc.name: SUB_Service_proxy_InitRestoreSession_0100
68  * @tc.desc: 测试 InitRestoreSession 注册restore Session接口调用成功和失败
69  * @tc.size: MEDIUM
70  * @tc.type: FUNC
71  * @tc.level Level 1
72  * @tc.require: I6F3GV
73  */
74 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitRestoreSession_0100, testing::ext::TestSize.Level1)
75 {
76     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitRestoreSession_0100";
77     if (proxy_ == nullptr) {
78         GTEST_LOG_(INFO) << "SUB_Service_proxy_InitRestoreSession_0100 proxy_ == nullptr";
79         return;
80     }
81     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
82         .Times(1)
83         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
84     int32_t result = proxy_->InitRestoreSession(remote_);
85     EXPECT_EQ(result, BError(BError::Codes::OK));
86 
87     result = proxy_->InitRestoreSession(nullptr);
88     EXPECT_NE(result, BError(BError::Codes::OK));
89     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitRestoreSession_0100";
90 }
91 
92 /**
93  * @tc.number: SUB_Service_proxy_InitBackupSession_0100
94  * @tc.name: SUB_Service_proxy_InitBackupSession_0100
95  * @tc.desc: 测试 InitBackupSession 注册backup Session接口调用成功和失败
96  * @tc.size: MEDIUM
97  * @tc.type: FUNC
98  * @tc.level Level 1
99  * @tc.require: I6F3GV
100  */
101 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitBackupSession_0100, testing::ext::TestSize.Level1)
102 {
103     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitBackupSession_0100";
104     if (proxy_ == nullptr) {
105         GTEST_LOG_(INFO) << "SUB_Service_proxy_InitBackupSession_0100 proxy_ == nullptr";
106         return;
107     }
108     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
109         .Times(1)
110         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
111 
112     int32_t result = proxy_->InitBackupSession(remote_);
113     EXPECT_EQ(result, BError(BError::Codes::OK));
114 
115     result = proxy_->InitBackupSession(nullptr);
116     EXPECT_NE(result, BError(BError::Codes::OK));
117     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitBackupSession_0100";
118 }
119 
120 /**
121  * @tc.number: SUB_Service_proxy_Start_0100
122  * @tc.name: SUB_Service_proxy_Start_0100
123  * @tc.desc: 测试 Start 启动备份恢复流程接口调用成功和失败
124  * @tc.size: MEDIUM
125  * @tc.type: FUNC
126  * @tc.level Level 1
127  * @tc.require: I6F3GV
128  */
129 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Start_0100, testing::ext::TestSize.Level1)
130 {
131     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Start_0100";
132     if (proxy_ == nullptr) {
133         GTEST_LOG_(INFO) << "SUB_Service_proxy_Start_0100 proxy_ == nullptr";
134         return;
135     }
136     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
137         .Times(2)
138         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
139         .WillOnce(Return(EPERM));
140     int32_t result = proxy_->Start();
141     EXPECT_EQ(result, BError(BError::Codes::OK));
142 
143     result = proxy_->Start();
144     EXPECT_NE(result, BError(BError::Codes::OK));
145     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Start_0100";
146 }
147 
148 /**
149  * @tc.number: SUB_Service_proxy_GetLocalCapabilities_0100
150  * @tc.name: SUB_Service_proxy_GetLocalCapabilities_0100
151  * @tc.desc: 测试 GetLocalCapabilities 获取能力文件接口调用成功和失败
152  * @tc.size: MEDIUM
153  * @tc.type: FUNC
154  * @tc.level Level 1
155  * @tc.require: I6F3GV
156  */
157 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilities_0100, testing::ext::TestSize.Level1)
158 {
159     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetLocalCapabilities_0100";
160     if (proxy_ == nullptr) {
161         GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilities_0100 proxy_ == nullptr";
162         return;
163     }
164     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
165         .Times(2)
166         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeGetLocalSendRequest))
167         .WillOnce(Return(EPERM));
168     UniqueFd fd = proxy_->GetLocalCapabilities();
169     EXPECT_GT(fd, BError(BError::Codes::OK));
170     UniqueFd fdErr = proxy_->GetLocalCapabilities();
171     EXPECT_LT(fdErr, BError(BError::Codes::OK));
172     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetLocalCapabilities_0100";
173 }
174 
175 /**
176  * @tc.number: SUB_Service_proxy_PublishFile_0100
177  * @tc.name: SUB_Service_proxy_PublishFile_0100
178  * @tc.desc: 测试 PublishFile 推送接口调用成功和失败
179  * @tc.size: MEDIUM
180  * @tc.type: FUNC
181  * @tc.level Level 1
182  * @tc.require: I6F3GV
183  */
184 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishFile_0100, testing::ext::TestSize.Level1)
185 {
186     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_PublishFile_0100";
187     if (proxy_ == nullptr) {
188         GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilities_0100 proxy_ == nullptr";
189         return;
190     }
191     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
192         .Times(2)
193         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
194         .WillOnce(Return(EPERM));
195     string bundleName = "com.example.app2backup";
196     string fileName = "1.tar";
197     BFileInfo fileInfo(bundleName, fileName, -1);
198     int32_t result = proxy_->PublishFile(fileInfo);
199     EXPECT_EQ(result, BError(BError::Codes::OK));
200 
201     result = proxy_->PublishFile(fileInfo);
202     EXPECT_NE(result, BError(BError::Codes::OK));
203     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_PublishFile_0100";
204 }
205 
206 /**
207  * @tc.number: SUB_Service_proxy_AppFileReady_0100
208  * @tc.name: SUB_Service_proxy_AppFileReady_0100
209  * @tc.desc: 测试 AppFileReady 文件就绪调用成功和失败
210  * @tc.size: MEDIUM
211  * @tc.type: FUNC
212  * @tc.level Level 1
213  * @tc.require: I6F3GV
214  */
215 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppFileReady_0100, testing::ext::TestSize.Level1)
216 {
217     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppFileReady_0100";
218     if (proxy_ == nullptr) {
219         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppFileReady_0100 proxy_ == nullptr";
220         return;
221     }
222     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
223         .Times(3)
224         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
225         .WillOnce(Return(EPERM))
226         .WillOnce(Return(EPERM));
227 
228     string bundleName = "com.example.app2backup";
229     TestManager tm("AppFileReady_GetFd_0100");
230     std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
231     UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
232 
233     int32_t result = proxy_->AppFileReady(bundleName, move(fd), 0);
234     EXPECT_EQ(result, BError(BError::Codes::OK));
235 
236     TestManager tmErr("AppFileReady_GetFd_0200");
237     UniqueFd fdErr(open(tmErr.GetRootDirCurTest().append(FILE_NAME).data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
238     result = proxy_->AppFileReady(bundleName, move(fdErr), 0);
239     EXPECT_NE(result, BError(BError::Codes::OK));
240     result = proxy_->AppFileReady(bundleName, UniqueFd(-1), 0);
241     EXPECT_NE(result, BError(BError::Codes::OK));
242     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppFileReady_0100";
243 }
244 
245 /**
246  * @tc.number: SUB_Service_proxy_AppDone_0100
247  * @tc.name: SUB_Service_proxy_AppDone_0100
248  * @tc.desc: 测试 AppDone ext备份恢复流程结束调用成功和失败
249  * @tc.size: MEDIUM
250  * @tc.type: FUNC
251  * @tc.level Level 1
252  * @tc.require: I6F3GV
253  */
254 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppDone_0100, testing::ext::TestSize.Level1)
255 {
256     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppDone_0100";
257     if (proxy_ == nullptr) {
258         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppDone_0100 proxy_ == nullptr";
259         return;
260     }
261     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
262         .Times(2)
263         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
264         .WillOnce(Return(EPERM));
265     int32_t result = proxy_->AppDone(BError(BError::Codes::OK));
266     EXPECT_EQ(result, BError(BError::Codes::OK));
267 
268     result = proxy_->AppDone(BError(BError::Codes::OK));
269     EXPECT_NE(result, BError(BError::Codes::OK));
270     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppDone_0100";
271 }
272 
273 /**
274  * @tc.number: SUB_Service_proxy_ServiceResultReport_0100
275  * @tc.name: SUB_Service_proxy_ServiceResultReport_0100
276  * @tc.desc: 测试 ServiceResultReport
277  * @tc.size: MEDIUM
278  * @tc.type: FUNC
279  * @tc.level Level 1
280  * @tc.require: I6F3GV
281  */
282 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_ServiceResultReport_0100, testing::ext::TestSize.Level1)
283 {
284     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_ServiceResultReport_0100";
285     if (proxy_ == nullptr) {
286         GTEST_LOG_(INFO) << "SUB_Service_proxy_ServiceResultReport_0100 proxy_ == nullptr";
287         return;
288     }
289     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
290         .Times(2)
291         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
292         .WillOnce(Return(EPERM));
293     std::string restoreRetInfo = "test_restoreRetInfo";
294     BackupRestoreScenario scenario = FULL_BACKUP;
295     int32_t result = proxy_->ServiceResultReport(restoreRetInfo, scenario, BError(BError::Codes::OK));
296     EXPECT_EQ(result, BError(BError::Codes::OK));
297 
298     result = proxy_->ServiceResultReport(restoreRetInfo, scenario, BError(BError::Codes::OK));
299     EXPECT_NE(result, BError(BError::Codes::OK));
300     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_ServiceResultReport_0100";
301 }
302 
303 /**
304  * @tc.number: SUB_Service_proxy_GetFileHandle_0100
305  * @tc.name: SUB_Service_proxy_GetFileHandle_0100
306  * @tc.desc: 测试 GetFileHandle 获取真实文件调用成功和失败
307  * @tc.size: MEDIUM
308  * @tc.type: FUNC
309  * @tc.level Level 1
310  * @tc.require: I6F3GV
311  */
312 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetFileHandle_0100, testing::ext::TestSize.Level1)
313 {
314     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetFileHandle_0100";
315     if (proxy_ == nullptr) {
316         GTEST_LOG_(INFO) << "SUB_Service_proxy_GetFileHandle_0100 proxy_ == nullptr";
317         return;
318     }
319     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
320         .Times(2)
321         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
322         .WillOnce(Return(EPERM));
323     string bundleName = "com.example.app2backup";
324     string fileName = "1.tar";
325     int32_t result = proxy_->GetFileHandle(bundleName, fileName);
326     EXPECT_EQ(result, BError(BError::Codes::OK));
327 
328     result = proxy_->GetFileHandle(bundleName, fileName);
329     EXPECT_NE(result, BError(BError::Codes::OK));
330     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetFileHandle_0100";
331 }
332 
333 /**
334  * @tc.number: SUB_Service_proxy_AppendBundlesRestoreSession_0100
335  * @tc.name: SUB_Service_proxy_AppendBundlesRestoreSession_0100
336  * @tc.desc: 测试 AppendBundlesRestoreSession 获取真实文件调用成功和失败
337  * @tc.size: MEDIUM
338  * @tc.type: FUNC
339  * @tc.level Level 1
340  * @tc.require: I6URNZ
341  */
342 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesRestoreSession_0100, testing::ext::TestSize.Level1)
343 {
344     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesRestoreSession_0100";
345     if (proxy_ == nullptr) {
346         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesRestoreSession_0100 proxy_ == nullptr";
347         return;
348     }
349     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
350         .Times(1)
351         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
352 
353     std::vector<string> bundleNames;
354     TestManager tm("BackupSession_GetFd_0100");
355     std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
356     UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
357     int32_t result = proxy_->AppendBundlesRestoreSession(move(fd), bundleNames);
358     EXPECT_EQ(result, BError(BError::Codes::OK));
359     result = proxy_->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames);
360     EXPECT_NE(result, BError(BError::Codes::OK));
361     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesRestoreSession_0100";
362 }
363 
364 /**
365  * @tc.number: SUB_Service_proxy_AppendBundlesRestoreSession_0101
366  * @tc.name: SUB_Service_proxy_AppendBundlesRestoreSession_0101
367  * @tc.desc: 测试 AppendBundlesRestoreSession 获取真实文件调用成功和失败
368  * @tc.size: MEDIUM
369  * @tc.type: FUNC
370  * @tc.level Level 1
371  * @tc.require: I6URNZ
372  */
373 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesRestoreSession_0101, testing::ext::TestSize.Level1)
374 {
375     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesRestoreSession_0101";
376     if (proxy_ == nullptr) {
377         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesRestoreSession_0101 proxy_ == nullptr";
378         return;
379     }
380     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
381         .Times(1)
382         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
383 
384     std::vector<string> bundleNames;
385     TestManager tm("BackupSession_GetFd_0100");
386     std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
387     UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
388     std::vector<std::string> detailInfos;
389     int32_t result = proxy_->AppendBundlesRestoreSession(move(fd), bundleNames, detailInfos);
390     EXPECT_EQ(result, BError(BError::Codes::OK));
391     result = proxy_->AppendBundlesRestoreSession(UniqueFd(-1), bundleNames, detailInfos);
392     EXPECT_NE(result, BError(BError::Codes::OK));
393     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesRestoreSession_0101";
394 }
395 
396 /**
397  * @tc.number: SUB_Service_proxy_AppendBundlesBackupSession_0100
398  * @tc.name: SUB_Service_proxy_AppendBundlesBackupSession_0100
399  * @tc.desc: 测试 AppendBundlesBackupSession 获取真实文件调用成功和失败
400  * @tc.size: MEDIUM
401  * @tc.type: FUNC
402  * @tc.level Level 1
403  * @tc.require: I6URNZ
404  */
405 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesBackupSession_0100, testing::ext::TestSize.Level1)
406 {
407     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesBackupSession_0100";
408     if (proxy_ == nullptr) {
409         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesBackupSession_0100 proxy_ == nullptr";
410         return;
411     }
412     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
413         .Times(2)
414         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
415         .WillOnce(Return(EPERM));
416 
417     std::vector<string> bundleNames;
418 
419     int32_t result = proxy_->AppendBundlesBackupSession(bundleNames);
420     EXPECT_EQ(result, BError(BError::Codes::OK));
421     result = proxy_->AppendBundlesBackupSession(bundleNames);
422     EXPECT_NE(result, BError(BError::Codes::OK));
423     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesBackupSession_0100";
424 }
425 
426 /**
427  * @tc.number: SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100
428  * @tc.name: SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100
429  * @tc.desc: 测试 AppendBundlesDetailsBackupSession
430  * @tc.size: MEDIUM
431  * @tc.type: FUNC
432  * @tc.level Level 1
433  * @tc.require: I6URNZ
434  */
435 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100, testing::ext::TestSize.Level1)
436 {
437     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100";
438     if (proxy_ == nullptr) {
439         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100 proxy_ == nullptr";
440         return;
441     }
442     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
443         .Times(2)
444         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
445         .WillOnce(Return(EPERM));
446 
447     std::vector<std::string> bundleNames;
448     std::vector<std::string> detailInfos;
449 
450     int32_t result = proxy_->AppendBundlesDetailsBackupSession(bundleNames, detailInfos);
451     EXPECT_EQ(result, BError(BError::Codes::OK));
452 
453     result = proxy_->AppendBundlesDetailsBackupSession(bundleNames, detailInfos);
454     EXPECT_NE(result, BError(BError::Codes::OK));
455     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesDetailsBackupSession_0100";
456 }
457 
458 /**
459  * @tc.number: SUB_Service_proxy_Finish_0100
460  * @tc.name: SUB_Service_proxy_Finish_0100
461  * @tc.desc: 测试 Finish 获取真实文件调用成功和失败
462  * @tc.size: MEDIUM
463  * @tc.type: FUNC
464  * @tc.level Level 1
465  * @tc.require: I6URNZ
466  */
467 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Finish_0100, testing::ext::TestSize.Level1)
468 {
469     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Finish_0100";
470     if (proxy_ == nullptr) {
471         GTEST_LOG_(INFO) << "SUB_Service_proxy_Finish_0100 proxy_ == nullptr";
472         return;
473     }
474     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
475         .Times(2)
476         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
477         .WillOnce(Return(EPERM));
478 
479     int32_t result = proxy_->Finish();
480     EXPECT_EQ(result, BError(BError::Codes::OK));
481     result = proxy_->Finish();
482     EXPECT_NE(result, BError(BError::Codes::OK));
483     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Finish_0100";
484 }
485 
486 /**
487  * @tc.number: SUB_Service_proxy_Release_0100
488  * @tc.name: SUB_Service_proxy_Release_0100
489  * @tc.desc: 测试 Release 调用成功和失败
490  * @tc.size: MEDIUM
491  * @tc.type: FUNC
492  * @tc.level Level 1
493  * @tc.require: I90ZV5
494  */
495 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Release_0100, testing::ext::TestSize.Level1)
496 {
497     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Release_0100";
498     if (proxy_ == nullptr) {
499         GTEST_LOG_(INFO) << "SUB_Service_proxy_Release_0100 proxy_ == nullptr";
500         return;
501     }
502     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
503         .Times(2)
504         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
505         .WillOnce(Return(EPERM));
506 
507     int32_t result = proxy_->Release();
508     EXPECT_EQ(result, BError(BError::Codes::OK));
509     result = proxy_->Release();
510     EXPECT_NE(result, BError(BError::Codes::OK));
511     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Release_0100";
512 }
513 
514 /**
515  * @tc.number: SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100
516  * @tc.name: SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100
517  * @tc.desc: 测试 GetLocalCapabilitiesIncremental 接口调用成功和失败
518  * @tc.size: MEDIUM
519  * @tc.type: FUNC
520  * @tc.level Level 1
521  * @tc.require: I90ZV5
522  */
523 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100, testing::ext::TestSize.Level1)
524 {
525     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100";
526     if (proxy_ == nullptr) {
527         GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100 proxy_ == nullptr";
528         return;
529     }
530     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
531         .Times(2)
532         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeGetLocalSendRequest))
533         .WillOnce(Return(EPERM));
534 
535     std::vector<BIncrementalData> bundleNames;
536     BIncrementalData data("com.example.app2backup", 0);
537     bundleNames.push_back(data);
538     UniqueFd fd = proxy_->GetLocalCapabilitiesIncremental(bundleNames);
539     EXPECT_GT(fd, BError(BError::Codes::OK));
540 
541     UniqueFd fdErr = proxy_->GetLocalCapabilitiesIncremental(bundleNames);
542     EXPECT_LT(fdErr, BError(BError::Codes::OK));
543     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetLocalCapabilitiesIncremental_0100";
544 }
545 
546 /**
547  * @tc.number: SUB_Service_proxy_InitIncrementalBackupSession_0100
548  * @tc.name: SUB_Service_proxy_InitIncrementalBackupSession_0100
549  * @tc.desc: 测试 InitIncrementalBackupSession 接口调用成功和失败
550  * @tc.size: MEDIUM
551  * @tc.type: FUNC
552  * @tc.level Level 1
553  * @tc.require: I90ZV5
554  */
555 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitIncrementalBackupSession_0100, testing::ext::TestSize.Level1)
556 {
557     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitIncrementalBackupSession_0100";
558     if (proxy_ == nullptr) {
559         GTEST_LOG_(INFO) << "SUB_Service_proxy_InitIncrementalBackupSession_0100 proxy_ == nullptr";
560         return;
561     }
562     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
563         .Times(1)
564         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
565 
566     int32_t result = proxy_->InitIncrementalBackupSession(remote_);
567     EXPECT_EQ(result, BError(BError::Codes::OK));
568 
569     result = proxy_->InitIncrementalBackupSession(nullptr);
570     EXPECT_NE(result, BError(BError::Codes::OK));
571     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitIncrementalBackupSession_0100";
572 }
573 
574 /**
575  * @tc.number: SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100
576  * @tc.name: SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100
577  * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 接口调用成功和失败
578  * @tc.size: MEDIUM
579  * @tc.type: FUNC
580  * @tc.level Level 1
581  * @tc.require: I90ZV5
582  */
583 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100, testing::ext::TestSize.Level1)
584 {
585     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100";
586     if (proxy_ == nullptr) {
587         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100 proxy_ == nullptr";
588         return;
589     }
590     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
591         .Times(2)
592         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
593         .WillOnce(Return(EPERM));
594 
595     std::vector<BIncrementalData> bundleNames;
596     int32_t result = proxy_->AppendBundlesIncrementalBackupSession(bundleNames);
597     EXPECT_EQ(result, BError(BError::Codes::OK));
598 
599     result = proxy_->AppendBundlesIncrementalBackupSession(bundleNames);
600     EXPECT_NE(result, BError(BError::Codes::OK));
601     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100";
602 }
603 
604 /**
605  * @tc.number: SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0101
606  * @tc.name: SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0101
607  * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 接口调用成功和失败
608  * @tc.size: MEDIUM
609  * @tc.type: FUNC
610  * @tc.level Level 1
611  * @tc.require: I90ZV5
612  */
613 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0101,
614     testing::ext::TestSize.Level1)
615 {
616     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppendBundlesDetailsIncrementalBackupSession_0101";
617     if (proxy_ == nullptr) {
618         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppendBundlesDetailsIncrementalBackupSession_0101 proxy_ == nullptr";
619         return;
620     }
621     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
622         .Times(2)
623         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
624         .WillOnce(Return(EPERM));
625 
626     std::vector<BIncrementalData> bundleNames;
627     std::vector<std::string> infos;
628     int32_t result = proxy_->AppendBundlesIncrementalBackupSession(bundleNames, infos);
629     EXPECT_EQ(result, BError(BError::Codes::OK));
630 
631     result = proxy_->AppendBundlesIncrementalBackupSession(bundleNames, infos);
632     EXPECT_NE(result, BError(BError::Codes::OK));
633     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppendBundlesDetailsIncrementalBackupSession_0101";
634 }
635 
636 /**
637  * @tc.number: SUB_Service_proxy_PublishIncrementalFile_0100
638  * @tc.name: SUB_Service_proxy_PublishIncrementalFile_0100
639  * @tc.desc: 测试 PublishIncrementalFile 接口调用成功和失败
640  * @tc.size: MEDIUM
641  * @tc.type: FUNC
642  * @tc.level Level 1
643  * @tc.require: I90ZV5
644  */
645 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishIncrementalFile_0100, testing::ext::TestSize.Level1)
646 {
647     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_PublishIncrementalFile_0100";
648     if (proxy_ == nullptr) {
649         GTEST_LOG_(INFO) << "SUB_Service_proxy_PublishIncrementalFile_0100 proxy_ == nullptr";
650         return;
651     }
652     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
653         .Times(2)
654         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
655         .WillOnce(Return(EPERM));
656 
657     string bundleName = "com.example.app2backup";
658     string fileName = "";
659     BFileInfo fileInfo(bundleName, fileName, -1);
660     int32_t result = proxy_->PublishIncrementalFile(fileInfo);
661     EXPECT_EQ(result, BError(BError::Codes::OK));
662     fileName = "test";
663     result = proxy_->PublishIncrementalFile(fileInfo);
664     EXPECT_NE(result, BError(BError::Codes::OK));
665     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_PublishIncrementalFile_0100";
666 }
667 
668 /**
669  * @tc.number: SUB_Service_proxy_PublishSAIncrementalFile_0100
670  * @tc.name: SUB_Service_proxy_PublishSAIncrementalFile_0100
671  * @tc.desc: 测试 PublishSAIncrementalFile 接口调用成功和失败
672  * @tc.size: MEDIUM
673  * @tc.type: FUNC
674  * @tc.level Level 1
675  * @tc.require: I90ZV5
676  */
677 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_PublishSAIncrementalFile_0100, testing::ext::TestSize.Level1)
678 {
679     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_PublishSAIncrementalFile_0100";
680     if (proxy_ == nullptr) {
681         GTEST_LOG_(INFO) << "SUB_Service_proxy_PublishSAIncrementalFile_0100 proxy_ == nullptr";
682         return;
683     }
684     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
685         .Times(2)
686         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
687         .WillOnce(Return(EPERM));
688 
689     string bundleName = "com.example.app2backup";
690     string fileName = "";
691     BFileInfo fileInfo(bundleName, fileName, -1);
692     TestManager tm("AppIncrementalFileReady_GetFd_0100");
693     std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
694     UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
695     ErrCode ret = proxy_->PublishSAIncrementalFile(fileInfo, move(fd));
696     EXPECT_EQ(ret, BError(BError::Codes::OK));
697 
698     TestManager tmErr("AppIncrementalFileReady_GetFd_0200");
699     UniqueFd fdErr(open(tmErr.GetRootDirCurTest().append(FILE_NAME).data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
700     ret = proxy_->PublishSAIncrementalFile(fileInfo, move(fdErr));
701     EXPECT_NE(ret, BError(BError::Codes::OK));
702     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_PublishSAIncrementalFile_0100";
703 }
704 
705 /**
706  * @tc.number: SUB_Service_proxy_AppIncrementalFileReady_0100
707  * @tc.name: SUB_Service_proxy_AppIncrementalFileReady_0100
708  * @tc.desc: 测试 AppIncrementalFileReady 接口成功和失败
709  * @tc.size: MEDIUM
710  * @tc.type: FUNC
711  * @tc.level Level 1
712  * @tc.require: I90ZV5
713  */
714 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalFileReady_0100, testing::ext::TestSize.Level1)
715 {
716     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppIncrementalFileReady_0100";
717     if (proxy_ == nullptr) {
718         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppIncrementalFileReady_0100 proxy_ == nullptr";
719         return;
720     }
721     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
722         .Times(2)
723         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
724         .WillOnce(Return(EPERM));
725 
726     string bundleName = "com.example.app2backup";
727     TestManager tm("AppIncrementalFileReady_GetFd_0100");
728     std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
729     UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
730     UniqueFd manifestFd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
731 
732     int32_t result = proxy_->AppIncrementalFileReady(bundleName, move(fd), move(manifestFd), 0);
733     EXPECT_EQ(result, BError(BError::Codes::OK));
734 
735     TestManager tmErr("AppIncrementalFileReady_GetFd_0200");
736     UniqueFd fdErr(open(tmErr.GetRootDirCurTest().append(FILE_NAME).data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
737     UniqueFd manifestFdErr(
738         open(tmErr.GetRootDirCurTest().append(FILE_NAME).data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
739     result = proxy_->AppIncrementalFileReady(bundleName, move(fdErr), move(manifestFdErr), 0);
740     EXPECT_NE(result, BError(BError::Codes::OK));
741     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppIncrementalFileReady_0100";
742 }
743 
744 /**
745  * @tc.number: SUB_Service_proxy_AppIncrementalFileReady_0200
746  * @tc.name: SUB_Service_proxy_AppIncrementalFileReady_0200
747  * @tc.desc: 测试 AppIncrementalFileReady 接口成功和失败
748  * @tc.size: MEDIUM
749  * @tc.type: FUNC
750  * @tc.level Level 1
751  * @tc.require: I90ZV5
752  */
753 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalFileReady_0200, testing::ext::TestSize.Level1)
754 {
755     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppIncrementalFileReady_0200";
756     if (proxy_ == nullptr) {
757         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppIncrementalFileReady_0200 proxy_ == nullptr";
758         return;
759     }
760     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
761         .Times(2)
762         .WillOnce(Return(0))
763         .WillOnce(Return(0));
764 
765     string bundleName = "com.example.app2backup";
766     TestManager tm("AppIncrementalFileReady_0200");
767     std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
768     UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
769     UniqueFd manifestFd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
770 
771     int32_t result = proxy_->AppIncrementalFileReady(bundleName, UniqueFd(-1), move(manifestFd), 0);
772     EXPECT_EQ(result, BError(BError::Codes::OK));
773 
774     result = proxy_->AppIncrementalFileReady(bundleName, move(fd), UniqueFd(-1), 0);
775     EXPECT_EQ(result, BError(BError::Codes::OK));
776     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppIncrementalFileReady_0200";
777 }
778 
779 /**
780  * @tc.number: SUB_Service_proxy_AppIncrementalDone_0100
781  * @tc.name: SUB_Service_proxy_AppIncrementalDone_0100
782  * @tc.desc: 测试 AppIncrementalDone 接口成功和失败
783  * @tc.size: MEDIUM
784  * @tc.type: FUNC
785  * @tc.level Level 1
786  * @tc.require: I90ZV5
787  */
788 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_AppIncrementalDone_0100, testing::ext::TestSize.Level1)
789 {
790     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_AppIncrementalDone_0100";
791     if (proxy_ == nullptr) {
792         GTEST_LOG_(INFO) << "SUB_Service_proxy_AppIncrementalDone_0100 proxy_ == nullptr";
793         return;
794     }
795     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
796         .Times(2)
797         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
798         .WillOnce(Return(EPERM));
799     int32_t result = proxy_->AppIncrementalDone(BError(BError::Codes::OK));
800     EXPECT_EQ(result, BError(BError::Codes::OK));
801 
802     result = proxy_->AppIncrementalDone(BError(BError::Codes::OK));
803     EXPECT_NE(result, BError(BError::Codes::OK));
804     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_AppIncrementalDone_0100";
805 }
806 
807 /**
808  * @tc.number: SUB_Service_proxy_GetIncrementalFileHandle_0100
809  * @tc.name: SUB_Service_proxy_GetIncrementalFileHandle_0100
810  * @tc.desc: 测试 GetIncrementalFileHandle 接口成功和失败
811  * @tc.size: MEDIUM
812  * @tc.type: FUNC
813  * @tc.level Level 1
814  * @tc.require: I90ZV5
815  */
816 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetIncrementalFileHandle_0100, testing::ext::TestSize.Level1)
817 {
818     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetIncrementalFileHandle_0100";
819     if (proxy_ == nullptr) {
820         GTEST_LOG_(INFO) << "SUB_Service_proxy_GetIncrementalFileHandle_0100 proxy_ == nullptr";
821         return;
822     }
823     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
824         .Times(2)
825         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
826         .WillOnce(Return(EPERM));
827     string bundleName = "com.example.app2backup";
828     string fileName = "1.tar";
829     int32_t result = proxy_->GetIncrementalFileHandle(bundleName, fileName);
830     EXPECT_EQ(result, BError(BError::Codes::OK));
831 
832     result = proxy_->GetIncrementalFileHandle(bundleName, fileName);
833     EXPECT_NE(result, BError(BError::Codes::OK));
834     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetIncrementalFileHandle_0100";
835 }
836 
837 /**
838  * @tc.number: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100
839  * @tc.name: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100
840  * @tc.desc: 测试 OnLoadSystemAbilitySuccess 接口
841  * @tc.size: MEDIUM
842  * @tc.type: FUNC
843  * @tc.level Level 1
844  * @tc.require: I6F3GV
845  */
846 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100, testing::ext::TestSize.Level1)
847 {
848     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100";
849     if (proxy_ == nullptr) {
850         GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100 proxy_ == nullptr";
851         return;
852     }
853     sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
854     EXPECT_NE(loadCallback, nullptr);
855     loadCallback->OnLoadSystemAbilitySuccess(SERVICE_ID, nullptr);
856     loadCallback = nullptr;
857     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_OnLoadSystemAbilitySuccess_0100";
858 }
859 
860 /**
861  * @tc.number: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101
862  * @tc.name: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101
863  * @tc.desc: 测试 OnLoadSystemAbilitySuccess 接口
864  * @tc.size: MEDIUM
865  * @tc.type: FUNC
866  * @tc.level Level 1
867  * @tc.require: I6F3GV
868  */
869 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101, testing::ext::TestSize.Level1)
870 {
871     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101";
872     if (proxy_ == nullptr) {
873         GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101 proxy_ == nullptr";
874         return;
875     }
876     sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
877     EXPECT_NE(loadCallback, nullptr);
878     int32_t systemAbilityId = 0;
879     sptr<MockIRemoteObject> remoteObject = new MockIRemoteObject();
880     loadCallback->OnLoadSystemAbilitySuccess(systemAbilityId, remoteObject);
881     loadCallback = nullptr;
882     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_OnLoadSystemAbilitySuccess_0101";
883 }
884 
885 /**
886  * @tc.number: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102
887  * @tc.name: SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102
888  * @tc.desc: 测试 OnLoadSystemAbilitySuccess 接口
889  * @tc.size: MEDIUM
890  * @tc.type: FUNC
891  * @tc.level Level 1
892  * @tc.require: I6F3GV
893  */
894 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102, testing::ext::TestSize.Level1)
895 {
896     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102";
897     if (proxy_ == nullptr) {
898         GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102 proxy_ == nullptr";
899         return;
900     }
901     sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
902     EXPECT_NE(loadCallback, nullptr);
903     int32_t systemAbilityId = 0;
904     loadCallback->OnLoadSystemAbilitySuccess(systemAbilityId, nullptr);
905     loadCallback = nullptr;
906     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_OnLoadSystemAbilitySuccess_0102";
907 }
908 
909 /**
910  * @tc.number: SUB_Service_proxy_OnLoadSystemAbilityFail_0100
911  * @tc.name: SUB_Service_proxy_OnLoadSystemAbilityFail_0100
912  * @tc.desc: 测试 OnLoadSystemAbilityFail 接口
913  * @tc.size: MEDIUM
914  * @tc.type: FUNC
915  * @tc.level Level 1
916  * @tc.require: I6F3GV
917  */
918 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_OnLoadSystemAbilityFail_0100, testing::ext::TestSize.Level1)
919 {
920     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_OnLoadSystemAbilityFail_0100";
921     if (proxy_ == nullptr) {
922         GTEST_LOG_(INFO) << "SUB_Service_proxy_OnLoadSystemAbilityFail_0100 proxy_ == nullptr";
923         return;
924     }
925     sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
926     EXPECT_NE(loadCallback, nullptr);
927     loadCallback->OnLoadSystemAbilityFail(SERVICE_ID);
928     loadCallback = nullptr;
929     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_OnLoadSystemAbilityFail_0100";
930 }
931 
932 /**
933  * @tc.number: SUB_Service_proxy_GetInstance_0100
934  * @tc.name: SUB_Service_proxy_GetInstance_0100
935  * @tc.desc: 测试 GetInstance 接口
936  * @tc.size: MEDIUM
937  * @tc.type: FUNC
938  * @tc.level Level 1
939  * @tc.require: I6F3GV
940  */
941 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetInstance_0100, testing::ext::TestSize.Level1)
942 {
943     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetInstance_0100";
944     if (proxy_ == nullptr) {
945         GTEST_LOG_(INFO) << "SUB_Service_proxy_GetInstance_0100 proxy_ == nullptr";
946         return;
947     }
948     GTEST_LOG_(INFO) << "MockLoadSystemAbility is false";
949     SetMockLoadSystemAbility(false);
950     auto proxy = ServiceProxy::GetInstance();
951     EXPECT_EQ(proxy, nullptr);
952     GTEST_LOG_(INFO) << "MockLoadSystemAbility is true";
953     SetMockLoadSystemAbility(true);
954     proxy = ServiceProxy::GetInstance();
955     EXPECT_EQ(proxy, nullptr);
956     sptr<ServiceProxy::ServiceProxyLoadCallback> loadCallback = new ServiceProxy::ServiceProxyLoadCallback();
957     sptr<IRemoteObject> object = new MockIRemoteObject();
958     loadCallback->OnLoadSystemAbilitySuccess(SERVICE_ID, object);
959     GTEST_LOG_(INFO) << "GetInstance is ok";
960     proxy = ServiceProxy::GetInstance();
961     EXPECT_NE(proxy, nullptr);
962     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetInstance_0100";
963 }
964 
965 /**
966  * @tc.number: SUB_Service_proxy_InvaildInstance_0100
967  * @tc.name: SUB_Service_proxy_InvaildInstance_0100
968  * @tc.desc: 测试 InvaildInstance 接口
969  * @tc.size: MEDIUM
970  * @tc.type: FUNC
971  * @tc.level Level 1
972  * @tc.require: I6F3GV
973  */
974 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InvaildInstance_0100, testing::ext::TestSize.Level1)
975 {
976     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InvaildInstance_0100";
977     if (proxy_ == nullptr) {
978         GTEST_LOG_(INFO) << "SUB_Service_proxy_InvaildInstance_0100 proxy_ == nullptr";
979         return;
980     }
981     ServiceProxy::InvaildInstance();
982     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InvaildInstance_0100";
983 }
984 
985 /**
986  * @tc.number: SUB_Service_proxy_GetBackupInfo_0100
987  * @tc.name: SUB_Service_proxy_GetBackupInfo_0100
988  * @tc.desc: 测试 GetBackupInfo 获取应用信息接口调用成功和失败
989  * @tc.size: MEDIUM
990  * @tc.type: FUNC
991  * @tc.level Level 1
992  * @tc.require: I6F3GV
993  */
994 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetBackupInfo_0100, testing::ext::TestSize.Level1)
995 {
996     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetBackupInfo_0100";
997     if (proxy_ == nullptr) {
998         GTEST_LOG_(INFO) << "SUB_Service_proxy_GetBackupInfo_0100 proxy_ == nullptr";
999         return;
1000     }
1001     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1002         .Times(1)
1003         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
1004     std::string result;
1005     std::string bundleName = "com.example.app2backup";
1006     int32_t ret = proxy_->GetBackupInfo(bundleName, result);
1007     EXPECT_EQ(ret, BError(BError::Codes::OK));
1008     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetBackupInfo_0100";
1009 }
1010 
1011 /**
1012  * @tc.number: SUB_Service_proxy_UpdateTimer_0100
1013  * @tc.name: SUB_Service_proxy_UpdateTimer_0100
1014  * @tc.desc: 测试 UpdateTimer 获取应用信息接口调用成功和失败
1015  * @tc.size: MEDIUM
1016  * @tc.type: FUNC
1017  * @tc.level Level 1
1018  * @tc.require: I6F3GV
1019  */
1020 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_UpdateTimer_0100, testing::ext::TestSize.Level1)
1021 {
1022     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_UpdateTimer_0100";
1023     if (proxy_ == nullptr) {
1024         GTEST_LOG_(INFO) << "SUB_Service_proxy_UpdateTimer_0100 proxy_ == nullptr";
1025         return;
1026     }
1027     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1028         .Times(1)
1029         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
1030     bool result;
1031     std::string bundleName = "com.example.app2backup";
1032     uint32_t timeout = 30000;
1033     int32_t ret = proxy_->UpdateTimer(bundleName, timeout, result);
1034     EXPECT_EQ(ret, BError(BError::Codes::OK));
1035     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_UpdateTimer_0100";
1036 }
1037 
1038 /**
1039  * @tc.number: SUB_Service_proxy_UpdateSendRate_0100
1040  * @tc.name: SUB_Service_proxy_UpdateSendRate_0100
1041  * @tc.desc: 测试 UpdateSendRate 获取应用信息接口调用成功和失败
1042  * @tc.size: MEDIUM
1043  * @tc.type: FUNC
1044  * @tc.level Level 1
1045  * @tc.require: I6F3GV
1046  */
1047 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_UpdateSendRate_0100, testing::ext::TestSize.Level1)
1048 {
1049     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_UpdateSendRate_0100";
1050     if (proxy_ == nullptr) {
1051         GTEST_LOG_(INFO) << "SUB_Service_proxy_UpdateSendRate_0100 proxy_ == nullptr";
1052         return;
1053     }
1054     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1055         .Times(1)
1056         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest));
1057     bool result;
1058     std::string bundleName = "com.example.app2backup";
1059     int32_t sendRate = 300;
1060     int32_t ret = proxy_->UpdateSendRate(bundleName, sendRate, result);
1061     EXPECT_EQ(ret, BError(BError::Codes::OK));
1062     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_UpdateSendRate_0100";
1063 }
1064 
1065 /**
1066  * @tc.number: SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100
1067  * @tc.name: SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100
1068  * @tc.desc: 测试 GetAppLocalListAndDoIncrementalBackup 执行DoBackup的接口成功和失败
1069  * @tc.size: MEDIUM
1070  * @tc.type: FUNC
1071  * @tc.level Level 1
1072  * @tc.require: I90ZV5
1073  */
1074 HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100, testing::ext::TestSize.Level1)
1075 {
1076     GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100";
1077     if (proxy_ == nullptr) {
1078         GTEST_LOG_(INFO) << "SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100 proxy_ == nullptr";
1079         return;
1080     }
1081     EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1082         .Times(2)
1083         .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
1084         .WillOnce(Return(EPERM));
1085     int32_t ret = proxy_->GetAppLocalListAndDoIncrementalBackup();
1086     EXPECT_EQ(ret, BError(BError::Codes::OK));
1087     ret = proxy_->GetAppLocalListAndDoIncrementalBackup();
1088     EXPECT_NE(ret, BError(BError::Codes::OK));
1089     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetAppLocalListAndDoIncrementalBackup_0100";
1090 }
1091 } // namespace OHOS::FileManagement::Backup