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 <cstdio>
17 #include <fcntl.h>
18 #include <gtest/gtest.h>
19 #include <sys/stat.h>
20 #include <sys/types.h>
21
22 #include "b_error/b_error.h"
23 #include "b_file_info.h"
24 #include "iservice_registry.h"
25 #include "message_parcel_mock.h"
26 #include "module_ipc/service_reverse_proxy.h"
27 #include "service_reverse_mock.h"
28 #include "test_manager.h"
29 #include "unique_fd.h"
30
31 namespace OHOS::FileManagement::Backup {
32 using namespace std;
33 using namespace testing;
34
35 namespace {
36 const string FILE_NAME = "1.tar";
37 const string BUNDLE_NAME = "com.example.app2backup";
38 const string FILE_NAME_MANIFEST = "manifest.rp";
39 const string RESULT_REPORT = "result_report";
40 } // namespace
41
42 class ServiceReverseProxyTest : public testing::Test {
43 public:
44 static void SetUpTestCase(void);
45 static void TearDownTestCase();
SetUp()46 void SetUp() override {};
TearDown()47 void TearDown() override {};
48
49 public:
50 static inline shared_ptr<ServiceReverseProxy> proxy_ = nullptr;
51 static inline sptr<ServiceReverseMock> mock_ = nullptr;
52 static inline shared_ptr<MessageParcelMock> messageParcelMock_ = nullptr;
53 };
54
SetUpTestCase(void)55 void ServiceReverseProxyTest::SetUpTestCase(void)
56 {
57 mock_ = sptr(new ServiceReverseMock());
58 proxy_ = make_shared<ServiceReverseProxy>(mock_);
59 messageParcelMock_ = make_shared<MessageParcelMock>();
60 MessageParcelMock::messageParcel = messageParcelMock_;
61 }
TearDownTestCase()62 void ServiceReverseProxyTest::TearDownTestCase()
63 {
64 mock_ = nullptr;
65 proxy_ = nullptr;
66 MessageParcelMock::messageParcel = nullptr;
67 messageParcelMock_ = nullptr;
68 }
69
70 /**
71 * @tc.number: SUB_ServiceReverse_proxy_BackupOnFileReady_0100
72 * @tc.name: SUB_ServiceReverse_proxy_BackupOnFileReady_0100
73 * @tc.desc: Test function of BackupOnFileReady interface for SUCCESS.
74 * @tc.size: MEDIUM
75 * @tc.type: FUNC
76 * @tc.level Level 1
77 * @tc.require: I6F3GV
78 */
79 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_0100, testing::ext::TestSize.Level1)
80 {
81 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnFileReady_0100";
82 try {
83 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
84 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
85 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
86 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true));
87 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
88 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
89 .Times(1)
90 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
91
92 TestManager tm("ServiceReverseProxyTest_GetFd_0100");
93 std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
94 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
95 EXPECT_TRUE(proxy_ != nullptr);
96 proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, fd, 0);
97 EXPECT_TRUE(true);
98 } catch (...) {
99 EXPECT_TRUE(false);
100 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnFileReady.";
101 }
102 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnFileReady_0100";
103 }
104
105 /**
106 * @tc.number: SUB_ServiceReverse_proxy_BackupOnFileReady_0101
107 * @tc.name: SUB_ServiceReverse_proxy_BackupOnFileReady_0101
108 * @tc.desc: Test function of BackupOnFileReady interface for FAILURE.
109 * @tc.size: MEDIUM
110 * @tc.type: FUNC
111 * @tc.level Level 1
112 * @tc.require: I9OVHB
113 */
114 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_0101, testing::ext::TestSize.Level1)
115 {
116 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnFileReady_0101";
117 try {
118 try {
119 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
120 EXPECT_TRUE(proxy_ != nullptr);
121 proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
122 EXPECT_TRUE(false);
123 } catch (BError &err) {
124 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
125 }
126
127 try {
128 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
129 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
130 EXPECT_TRUE(proxy_ != nullptr);
131 proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
132 EXPECT_TRUE(false);
133 } catch (BError &err) {
134 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
135 }
136
137 try {
138 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
139 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
140 EXPECT_TRUE(proxy_ != nullptr);
141 proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
142 EXPECT_TRUE(false);
143 } catch (BError &err) {
144 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
145 }
146
147 try {
148 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
149 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
150 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
151 EXPECT_TRUE(proxy_ != nullptr);
152 proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
153 EXPECT_TRUE(false);
154 } catch (BError &err) {
155 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
156 }
157 } catch (...) {
158 EXPECT_TRUE(false);
159 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnFileReady.";
160 }
161 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnFileReady_0101";
162 }
163
164 /**
165 * @tc.number: SUB_ServiceReverse_proxy_BackupOnFileReady_0102
166 * @tc.name: SUB_ServiceReverse_proxy_BackupOnFileReady_0102
167 * @tc.desc: Test function of BackupOnFileReady interface for FAILURE.
168 * @tc.size: MEDIUM
169 * @tc.type: FUNC
170 * @tc.level Level 1
171 * @tc.require: I9OVHB
172 */
173 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_0102, testing::ext::TestSize.Level1)
174 {
175 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnFileReady_0102";
176 try {
177 try {
178 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
179 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
180 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
181 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
182 EXPECT_TRUE(proxy_ != nullptr);
183 proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
184 EXPECT_TRUE(false);
185 } catch (BError &err) {
186 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
187 }
188
189 try {
190 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
191 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
192 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
193 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(false));
194 EXPECT_TRUE(proxy_ != nullptr);
195 proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
196 EXPECT_TRUE(false);
197 } catch (BError &err) {
198 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
199 }
200
201 try {
202 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
203 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
204 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
205 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true));
206 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
207 EXPECT_TRUE(proxy_ != nullptr);
208 proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
209 EXPECT_TRUE(false);
210 } catch (BError &err) {
211 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
212 }
213 } catch (...) {
214 EXPECT_TRUE(false);
215 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnFileReady.";
216 }
217 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnFileReady_0102";
218 }
219
220 /**
221 * @tc.number: SUB_ServiceReverse_proxy_BackupOnFileReady_0103
222 * @tc.name: SUB_ServiceReverse_proxy_BackupOnFileReady_0103
223 * @tc.desc: Test function of BackupOnFileReady interface for FAILURE.
224 * @tc.size: MEDIUM
225 * @tc.type: FUNC
226 * @tc.level Level 1
227 * @tc.require: I9OVHB
228 */
229 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_0103, testing::ext::TestSize.Level1)
230 {
231 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnFileReady_0103";
232 try {
233 try {
234 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
235 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
236 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
237 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true));
238 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
239 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
240 EXPECT_TRUE(proxy_ != nullptr);
241 proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
242 EXPECT_TRUE(false);
243 } catch (BError &err) {
244 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
245 }
246 } catch (...) {
247 EXPECT_TRUE(false);
248 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnFileReady.";
249 }
250 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnFileReady_0103";
251 }
252
253 /**
254 * @tc.number: SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100
255 * @tc.name: SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100
256 * @tc.desc: Test function of BackupOnBundleStarted interface for SUCCESS.
257 * @tc.size: MEDIUM
258 * @tc.type: FUNC
259 * @tc.level Level 1
260 * @tc.require: I6F3GV
261 */
262 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100, testing::ext::TestSize.Level1)
263 {
264 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100";
265 try {
266 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
267 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
268 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
269 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
270 .Times(1)
271 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
272 EXPECT_TRUE(proxy_ != nullptr);
273 proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
274 EXPECT_TRUE(true);
275 } catch (...) {
276 EXPECT_TRUE(false);
277 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnBundleStarted.";
278 }
279 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100";
280 }
281
282 /**
283 * @tc.number: SUB_ServiceReverse_proxy_BackupOnBundleStarted_0101
284 * @tc.name: SUB_ServiceReverse_proxy_BackupOnBundleStarted_0101
285 * @tc.desc: Test function of BackupOnBundleStarted interface for FAILURE.
286 * @tc.size: MEDIUM
287 * @tc.type: FUNC
288 * @tc.level Level 1
289 * @tc.require: I6F3GV
290 */
291 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleStarted_0101, testing::ext::TestSize.Level1)
292 {
293 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnBundleStarted_0101";
294 try {
295 try {
296 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
297 EXPECT_TRUE(proxy_ != nullptr);
298 proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
299 EXPECT_TRUE(false);
300 } catch (BError &err) {
301 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
302 }
303
304 try {
305 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
306 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
307 EXPECT_TRUE(proxy_ != nullptr);
308 proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
309 EXPECT_TRUE(false);
310 } catch (BError &err) {
311 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
312 }
313
314 try {
315 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
316 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
317 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
318 EXPECT_TRUE(proxy_ != nullptr);
319 proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
320 EXPECT_TRUE(false);
321 } catch (BError &err) {
322 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
323 }
324
325 try {
326 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
327 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
328 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
329 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
330 EXPECT_TRUE(proxy_ != nullptr);
331 proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
332 EXPECT_TRUE(false);
333 } catch (BError &err) {
334 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
335 }
336 } catch (...) {
337 EXPECT_TRUE(false);
338 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnBundleStarted.";
339 }
340 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnBundleStarted_0101";
341 }
342
343 /**
344 * @tc.number: SUB_ServiceReverse_proxy_BackupOnBundleFinished_0100
345 * @tc.name: SUB_ServiceReverse_proxy_BackupOnBundleFinished_0100
346 * @tc.desc: Test function of BackupOnBundleFinished interface for SUCCESS.
347 * @tc.size: MEDIUM
348 * @tc.type: FUNC
349 * @tc.level Level 1
350 * @tc.require: I6F3GV
351 */
352 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleFinished_0100, testing::ext::TestSize.Level1)
353 {
354 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnBundleFinished_0100";
355 try {
356 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
357 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
358 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
359 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
360 .Times(1)
361 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
362 EXPECT_TRUE(proxy_ != nullptr);
363 proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
364 EXPECT_TRUE(true);
365 } catch (...) {
366 EXPECT_TRUE(false);
367 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnBundleFinished.";
368 }
369 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnBundleFinished_0100";
370 }
371
372 /**
373 * @tc.number: SUB_ServiceReverse_proxy_BackupOnBundleFinished_0101
374 * @tc.name: SUB_ServiceReverse_proxy_BackupOnBundleFinished_0101
375 * @tc.desc: Test function of BackupOnBundleFinished interface for FAILURE.
376 * @tc.size: MEDIUM
377 * @tc.type: FUNC
378 * @tc.level Level 1
379 * @tc.require: I6F3GV
380 */
381 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleFinished_0101, testing::ext::TestSize.Level1)
382 {
383 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnBundleFinished_0101";
384 try {
385 try {
386 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
387 EXPECT_TRUE(proxy_ != nullptr);
388 proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
389 EXPECT_TRUE(false);
390 } catch (BError &err) {
391 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
392 }
393
394 try {
395 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
396 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
397 proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
398 EXPECT_TRUE(false);
399 } catch (BError &err) {
400 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
401 }
402
403 try {
404 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
405 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
406 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
407 proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
408 EXPECT_TRUE(false);
409 } catch (BError &err) {
410 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
411 }
412
413 try {
414 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
415 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
416 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
417 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
418 proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
419 EXPECT_TRUE(false);
420 } catch (BError &err) {
421 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
422 }
423 } catch (...) {
424 EXPECT_TRUE(false);
425 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnBundleFinished.";
426 }
427 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnBundleFinished_0101";
428 }
429
430 /**
431 * @tc.number: SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0100
432 * @tc.name: SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0100
433 * @tc.desc: Test function of BackupOnAllBundlesFinished interface for SUCCESS.
434 * @tc.size: MEDIUM
435 * @tc.type: FUNC
436 * @tc.level Level 1
437 * @tc.require: I6F3GV
438 */
439 HWTEST_F(ServiceReverseProxyTest,
440 SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0100,
441 testing::ext::TestSize.Level1)
442 {
443 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0100";
444 try {
445 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
446 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
447 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
448 .Times(1)
449 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
450 EXPECT_TRUE(proxy_ != nullptr);
451 proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
452 EXPECT_TRUE(true);
453 } catch (...) {
454 EXPECT_TRUE(false);
455 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnAllBundlesFinished.";
456 }
457 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0100";
458 }
459
460 /**
461 * @tc.number: SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0101
462 * @tc.name: SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0101
463 * @tc.desc: Test function of BackupOnAllBundlesFinished interface for FAILURE.
464 * @tc.size: MEDIUM
465 * @tc.type: FUNC
466 * @tc.level Level 1
467 * @tc.require: I9OVHB
468 */
469 HWTEST_F(ServiceReverseProxyTest,
470 SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0101,
471 testing::ext::TestSize.Level1)
472 {
473 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0101";
474 try {
475 try {
476 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
477 EXPECT_TRUE(proxy_ != nullptr);
478 proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
479 EXPECT_TRUE(false);
480 } catch (BError &err) {
481 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
482 }
483
484 try {
485 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
486 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
487 proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
488 EXPECT_TRUE(false);
489 } catch (BError &err) {
490 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
491 }
492
493 try {
494 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
495 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
496 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
497 proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
498 EXPECT_TRUE(false);
499 } catch (BError &err) {
500 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
501 }
502 } catch (...) {
503 EXPECT_TRUE(false);
504 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnAllBundlesFinished.";
505 }
506 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0101";
507 }
508
509 /**
510 * @tc.number: SUB_ServiceReverse_proxy_BackupOnResultReport_0100
511 * @tc.name: SUB_ServiceReverse_proxy_BackupOnResultReport_0100
512 * @tc.desc: Test function of BackupOnResultReport interface for SUCCESS.
513 * @tc.size: MEDIUM
514 * @tc.type: FUNC
515 * @tc.level Level 1
516 * @tc.require: I6F3GV
517 */
518 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnResultReport_0100, testing::ext::TestSize.Level1)
519 {
520 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnResultReport_0100";
521 try {
522 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
523 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
524 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
525 .Times(1)
526 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
527 std::string bundleName = "app01";
528 EXPECT_TRUE(proxy_ != nullptr);
529 proxy_->BackupOnResultReport(RESULT_REPORT, bundleName);
530 EXPECT_TRUE(true);
531 } catch (...) {
532 EXPECT_TRUE(false);
533 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnResultReport.";
534 }
535 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnResultReport_0100";
536 }
537
538 /**
539 * @tc.number: SUB_ServiceReverse_proxy_BackupOnResultReport_0101
540 * @tc.name: SUB_ServiceReverse_proxy_BackupOnResultReport_0101
541 * @tc.desc: Test function of BackupOnResultReport interface for FAILURE.
542 * @tc.size: MEDIUM
543 * @tc.type: FUNC
544 * @tc.level Level 1
545 * @tc.require: I9OVHB
546 */
547 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnResultReport_0101, testing::ext::TestSize.Level1)
548 {
549 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnResultReport_0101";
550 try {
551 std::string bundleName = "app01";
552 try {
553 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
554 EXPECT_TRUE(proxy_ != nullptr);
555 proxy_->BackupOnResultReport(RESULT_REPORT, bundleName);
556 EXPECT_TRUE(false);
557 } catch (BError &err) {
558 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
559 }
560
561 try {
562 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
563 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
564 proxy_->BackupOnResultReport(RESULT_REPORT, bundleName);
565 EXPECT_TRUE(false);
566 } catch (BError &err) {
567 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
568 }
569
570 try {
571 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
572 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
573 proxy_->BackupOnResultReport(RESULT_REPORT, bundleName);
574 EXPECT_TRUE(false);
575 } catch (BError &err) {
576 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
577 }
578
579 try {
580 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
581 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
582 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
583 proxy_->BackupOnResultReport(RESULT_REPORT, bundleName);
584 EXPECT_TRUE(false);
585 } catch (BError &err) {
586 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
587 }
588 } catch (...) {
589 EXPECT_TRUE(false);
590 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnResultReport.";
591 }
592 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnResultReport_0101";
593 }
594
595 /**
596 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0100
597 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0100
598 * @tc.desc: Test function of RestoreOnBundleStarted interface for SUCCESS.
599 * @tc.size: MEDIUM
600 * @tc.type: FUNC
601 * @tc.level Level 1
602 * @tc.require: I6F3GV
603 */
604 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0100, testing::ext::TestSize.Level1)
605 {
606 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0100";
607 try {
608 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
609 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
610 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
611 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
612 .Times(1)
613 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
614 EXPECT_TRUE(proxy_ != nullptr);
615 proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
616 EXPECT_TRUE(true);
617 } catch (...) {
618 EXPECT_TRUE(false);
619 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnBundleStarted.";
620 }
621 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0100";
622 }
623
624 /**
625 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0101
626 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0101
627 * @tc.desc: Test function of RestoreOnBundleStarted interface for FAILURE.
628 * @tc.size: MEDIUM
629 * @tc.type: FUNC
630 * @tc.level Level 1
631 * @tc.require: I9OVHB
632 */
633 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0101, testing::ext::TestSize.Level1)
634 {
635 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0101";
636 try {
637 try {
638 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
639 EXPECT_TRUE(proxy_ != nullptr);
640 proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
641 EXPECT_TRUE(false);
642 } catch (BError &err) {
643 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
644 }
645
646 try {
647 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
648 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
649 proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
650 EXPECT_TRUE(false);
651 } catch (BError &err) {
652 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
653 }
654
655 try {
656 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
657 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
658 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
659 proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
660 EXPECT_TRUE(false);
661 } catch (BError &err) {
662 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
663 }
664
665 try {
666 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
667 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
668 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
669 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
670 proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
671 EXPECT_TRUE(false);
672 } catch (BError &err) {
673 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
674 }
675 } catch (...) {
676 EXPECT_TRUE(false);
677 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnBundleStarted.";
678 }
679 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0101";
680 }
681
682 /**
683 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0100
684 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0100
685 * @tc.desc: Test function of RestoreOnBundleFinished interface for SUCCESS.
686 * @tc.size: MEDIUM
687 * @tc.type: FUNC
688 * @tc.level Level 1
689 * @tc.require: I6F3GV
690 */
691 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0100, testing::ext::TestSize.Level1)
692 {
693 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0100";
694 try {
695 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
696 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
697 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
698 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
699 .Times(1)
700 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
701 EXPECT_TRUE(proxy_ != nullptr);
702 proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
703 EXPECT_TRUE(true);
704 } catch (...) {
705 EXPECT_TRUE(false);
706 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnBundleFinished.";
707 }
708 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0100";
709 }
710
711 /**
712 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0101
713 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0101
714 * @tc.desc: Test function of RestoreOnBundleFinished interface for FAILURE.
715 * @tc.size: MEDIUM
716 * @tc.type: FUNC
717 * @tc.level Level 1
718 * @tc.require: I9OVHB
719 */
720 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0101, testing::ext::TestSize.Level1)
721 {
722 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0101";
723 try {
724 try {
725 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
726 EXPECT_TRUE(proxy_ != nullptr);
727 proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
728 EXPECT_TRUE(false);
729 } catch (BError &err) {
730 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
731 }
732
733 try {
734 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
735 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
736 proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
737 EXPECT_TRUE(false);
738 } catch (BError &err) {
739 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
740 }
741
742 try {
743 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
744 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
745 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
746 proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
747 EXPECT_TRUE(false);
748 } catch (BError &err) {
749 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
750 }
751
752 try {
753 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
754 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
755 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
756 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
757 proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
758 EXPECT_TRUE(false);
759 } catch (BError &err) {
760 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
761 }
762 } catch (...) {
763 EXPECT_TRUE(false);
764 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnBundleFinished.";
765 }
766 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0101";
767 }
768
769 /**
770 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0100
771 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0100
772 * @tc.desc: Test function of RestoreOnAllBundlesFinished interface for SUCCESS.
773 * @tc.size: MEDIUM
774 * @tc.type: FUNC
775 * @tc.level Level 1
776 * @tc.require: I6F3GV
777 */
778 HWTEST_F(ServiceReverseProxyTest,
779 SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0100,
780 testing::ext::TestSize.Level1)
781 {
782 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0100";
783 try {
784 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
785 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
786 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
787 .Times(1)
788 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
789 EXPECT_TRUE(proxy_ != nullptr);
790 proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
791 EXPECT_TRUE(true);
792 } catch (...) {
793 EXPECT_TRUE(false);
794 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnAllBundlesFinished.";
795 }
796 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0100";
797 }
798
799 /**
800 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0101
801 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0101
802 * @tc.desc: Test function of RestoreOnAllBundlesFinished interface for FAILURE.
803 * @tc.size: MEDIUM
804 * @tc.type: FUNC
805 * @tc.level Level 1
806 * @tc.require: I9OVHB
807 */
808 HWTEST_F(ServiceReverseProxyTest,
809 SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0101,
810 testing::ext::TestSize.Level1)
811 {
812 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0101";
813 try {
814 try {
815 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
816 EXPECT_TRUE(proxy_ != nullptr);
817 proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
818 EXPECT_TRUE(false);
819 } catch (BError &err) {
820 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
821 }
822
823 try {
824 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
825 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
826 proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
827 EXPECT_TRUE(false);
828 } catch (BError &err) {
829 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
830 }
831
832 try {
833 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
834 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
835 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
836 proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
837 EXPECT_TRUE(false);
838 } catch (BError &err) {
839 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
840 }
841 } catch (...) {
842 EXPECT_TRUE(false);
843 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnAllBundlesFinished.";
844 }
845 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0101";
846 }
847
848 /**
849 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnFileReady_0100
850 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnFileReady_0100
851 * @tc.desc: Test function of RestoreOnFileReady interface for SUCCESS.
852 * @tc.size: MEDIUM
853 * @tc.type: FUNC
854 * @tc.level Level 1
855 * @tc.require: I6F3GV
856 */
857 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_0100, testing::ext::TestSize.Level1)
858 {
859 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnFileReady_0100";
860 try {
861 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
862 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
863 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
864 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true));
865 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
866 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
867 .Times(1)
868 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
869
870 TestManager tm("ServiceReverseProxyTest_GetFd_0200");
871 int32_t errCode = 0;
872 std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
873 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
874 if (fd < 0) {
875 errCode = BError::GetCodeByErrno(errno);
876 }
877 EXPECT_TRUE(proxy_ != nullptr);
878 proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, fd, errCode);
879 EXPECT_TRUE(true);
880 } catch (...) {
881 EXPECT_TRUE(false);
882 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnFileReady.";
883 }
884 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnFileReady_0100";
885 }
886
887 /**
888 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnFileReady_0101
889 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnFileReady_0101
890 * @tc.desc: Test function of RestoreOnFileReady interface for FAILURE.
891 * @tc.size: MEDIUM
892 * @tc.type: FUNC
893 * @tc.level Level 1
894 * @tc.require: I9OVHB
895 */
896 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_0101, testing::ext::TestSize.Level1)
897 {
898 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnFileReady_0101";
899 try {
900 try {
901 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
902 EXPECT_TRUE(proxy_ != nullptr);
903 proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
904 EXPECT_TRUE(false);
905 } catch (BError &err) {
906 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
907 }
908
909 try {
910 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
911 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
912 proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
913 EXPECT_TRUE(false);
914 } catch (BError &err) {
915 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
916 }
917
918 try {
919 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
920 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
921 proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
922 EXPECT_TRUE(false);
923 } catch (BError &err) {
924 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
925 }
926 } catch (...) {
927 EXPECT_TRUE(false);
928 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnFileReady.";
929 }
930 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnFileReady_0101";
931 }
932
933 /**
934 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnFileReady_0102
935 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnFileReady_0102
936 * @tc.desc: Test function of RestoreOnFileReady interface for FAILURE.
937 * @tc.size: MEDIUM
938 * @tc.type: FUNC
939 * @tc.level Level 1
940 * @tc.require: I9OVHB
941 */
942 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_0102, testing::ext::TestSize.Level1)
943 {
944 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnFileReady_0102";
945 try {
946 try {
947 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
948 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
949 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
950 EXPECT_TRUE(proxy_ != nullptr);
951 proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
952 EXPECT_TRUE(false);
953 } catch (BError &err) {
954 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
955 }
956
957 try {
958 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
959 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
960 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
961 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(false));
962 proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0);
963 EXPECT_TRUE(false);
964 } catch (BError &err) {
965 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
966 }
967 } catch (...) {
968 EXPECT_TRUE(false);
969 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnFileReady.";
970 }
971 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnFileReady_0102";
972 }
973
974 /**
975 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100
976 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100
977 * @tc.desc: Test function of IncrementalBackupOnFileReady interface for SUCCESS.
978 * @tc.size: MEDIUM
979 * @tc.type: FUNC
980 * @tc.level Level 1
981 * @tc.require: I911LB
982 */
983 HWTEST_F(ServiceReverseProxyTest,
984 SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100,
985 testing::ext::TestSize.Level1)
986 {
987 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100";
988 try {
989 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
990 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
991 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
992 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
993 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
994 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
995 .Times(1)
996 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
997
998 TestManager tm("ServiceReverseProxyTest_GetFd_0300");
999 std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
1000 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
1001 TestManager tm1("ServiceReverseProxyTest_GetFd_0301");
1002 std::string manifestFilePath = tm1.GetRootDirCurTest().append(FILE_NAME_MANIFEST);
1003 UniqueFd manifestFd(open(manifestFilePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
1004 EXPECT_TRUE(proxy_ != nullptr);
1005 proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, fd, manifestFd, 0);
1006 EXPECT_TRUE(true);
1007 } catch (...) {
1008 EXPECT_TRUE(false);
1009 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnFileReady.";
1010 }
1011 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100";
1012 }
1013
1014 /**
1015 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0101
1016 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0101
1017 * @tc.desc: Test function of IncrementalBackupOnFileReady interface for FAILURE.
1018 * @tc.size: MEDIUM
1019 * @tc.type: FUNC
1020 * @tc.level Level 1
1021 * @tc.require: I9OVHB
1022 */
1023 HWTEST_F(ServiceReverseProxyTest,
1024 SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0101,
1025 testing::ext::TestSize.Level1)
1026 {
1027 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0101";
1028 try {
1029 try {
1030 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1031 EXPECT_TRUE(proxy_ != nullptr);
1032 proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1033 EXPECT_TRUE(false);
1034 } catch (BError &err) {
1035 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1036 }
1037
1038 try {
1039 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1040 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
1041 proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1042 EXPECT_TRUE(false);
1043 } catch (BError &err) {
1044 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1045 }
1046
1047 try {
1048 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1049 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
1050 proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1051 EXPECT_TRUE(false);
1052 } catch (BError &err) {
1053 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1054 }
1055 } catch (...) {
1056 EXPECT_TRUE(false);
1057 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnFileReady.";
1058 }
1059 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0101";
1060 }
1061
1062 /**
1063 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0102
1064 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0102
1065 * @tc.desc: Test function of IncrementalBackupOnFileReady interface for FAILURE.
1066 * @tc.size: MEDIUM
1067 * @tc.type: FUNC
1068 * @tc.level Level 1
1069 * @tc.require: I9OVHB
1070 */
1071 HWTEST_F(ServiceReverseProxyTest,
1072 SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0102,
1073 testing::ext::TestSize.Level1)
1074 {
1075 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0102";
1076 try {
1077 try {
1078 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1079 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1080 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
1081 EXPECT_TRUE(proxy_ != nullptr);
1082 proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1083 EXPECT_TRUE(false);
1084 } catch (BError &err) {
1085 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1086 }
1087
1088 try {
1089 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1090 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1091 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1092 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1093 proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0, 0);
1094 EXPECT_TRUE(false);
1095 } catch (BError &err) {
1096 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1097 }
1098
1099 try {
1100 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1101 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1102 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1103 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(false));
1104 proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1105 EXPECT_TRUE(false);
1106 } catch (BError &err) {
1107 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1108 }
1109 } catch (...) {
1110 EXPECT_TRUE(false);
1111 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnFileReady.";
1112 }
1113 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0102";
1114 }
1115
1116 /**
1117 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0103
1118 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0103
1119 * @tc.desc: Test function of IncrementalBackupOnFileReady interface for FAILURE.
1120 * @tc.size: MEDIUM
1121 * @tc.type: FUNC
1122 * @tc.level Level 1
1123 * @tc.require: I9OVHB
1124 */
1125 HWTEST_F(ServiceReverseProxyTest,
1126 SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0103,
1127 testing::ext::TestSize.Level1)
1128 {
1129 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0103";
1130 try {
1131 try {
1132 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1133 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1134 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1135 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(false));
1136 EXPECT_TRUE(proxy_ != nullptr);
1137 proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1138 EXPECT_TRUE(false);
1139 } catch (BError &err) {
1140 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1141 }
1142
1143 try {
1144 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1145 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1146 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1147 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
1148 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1149 proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1150 EXPECT_TRUE(false);
1151 } catch (BError &err) {
1152 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1153 }
1154
1155 try {
1156 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1157 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1158 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1159 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
1160 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1161 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
1162 proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1163 EXPECT_TRUE(false);
1164 } catch (BError &err) {
1165 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1166 }
1167 } catch (...) {
1168 EXPECT_TRUE(false);
1169 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnFileReady.";
1170 }
1171 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0103";
1172 }
1173
1174 /**
1175 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100
1176 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100
1177 * @tc.desc: Test function of IncrementalBackupOnBundleStarted interface for SUCCESS.
1178 * @tc.size: MEDIUM
1179 * @tc.type: FUNC
1180 * @tc.level Level 1
1181 * @tc.require: I911LB
1182 */
1183 HWTEST_F(ServiceReverseProxyTest,
1184 SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100,
1185 testing::ext::TestSize.Level1)
1186 {
1187 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100";
1188 try {
1189 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1190 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1191 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
1192 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1193 .Times(1)
1194 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
1195 EXPECT_TRUE(proxy_ != nullptr);
1196 proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1197 EXPECT_TRUE(true);
1198 } catch (...) {
1199 EXPECT_TRUE(false);
1200 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnBundleStarted.";
1201 }
1202 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100";
1203 }
1204
1205 /**
1206 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0101
1207 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0101
1208 * @tc.desc: Test function of IncrementalBackupOnBundleStarted interface for FAILURE.
1209 * @tc.size: MEDIUM
1210 * @tc.type: FUNC
1211 * @tc.level Level 1
1212 * @tc.require: I9OVHB
1213 */
1214 HWTEST_F(ServiceReverseProxyTest,
1215 SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0101,
1216 testing::ext::TestSize.Level1)
1217 {
1218 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0101";
1219 try {
1220 try {
1221 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1222 EXPECT_TRUE(proxy_ != nullptr);
1223 proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1224 EXPECT_TRUE(false);
1225 } catch (BError &err) {
1226 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1227 }
1228
1229 try {
1230 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1231 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1232 proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1233 EXPECT_TRUE(false);
1234 } catch (BError &err) {
1235 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1236 }
1237
1238 try {
1239 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1240 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1241 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
1242 proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1243 EXPECT_TRUE(false);
1244 } catch (BError &err) {
1245 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1246 }
1247
1248 try {
1249 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1250 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1251 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
1252 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
1253 proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1254 EXPECT_TRUE(false);
1255 } catch (BError &err) {
1256 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1257 }
1258 } catch (...) {
1259 EXPECT_TRUE(false);
1260 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnBundleStarted.";
1261 }
1262 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0101";
1263 }
1264
1265 /**
1266 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0100
1267 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0100
1268 * @tc.desc: Test function of IncrementalBackupOnBundleFinished interface for SUCCESS.
1269 * @tc.size: MEDIUM
1270 * @tc.type: FUNC
1271 * @tc.level Level 1
1272 * @tc.require: I911LB
1273 */
1274 HWTEST_F(ServiceReverseProxyTest,
1275 SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0100,
1276 testing::ext::TestSize.Level1)
1277 {
1278 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0100";
1279 try {
1280 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1281 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1282 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
1283 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1284 .Times(1)
1285 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
1286 EXPECT_TRUE(proxy_ != nullptr);
1287 proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1288 EXPECT_TRUE(true);
1289 } catch (...) {
1290 EXPECT_TRUE(false);
1291 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnBundleFinished.";
1292 }
1293 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0100";
1294 }
1295
1296 /**
1297 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101
1298 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101
1299 * @tc.desc: Test function of IncrementalBackupOnBundleFinished interface for FAILURE.
1300 * @tc.size: MEDIUM
1301 * @tc.type: FUNC
1302 * @tc.level Level 1
1303 * @tc.require: I9OVHB
1304 */
1305 HWTEST_F(ServiceReverseProxyTest,
1306 SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101,
1307 testing::ext::TestSize.Level1)
1308 {
1309 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101";
1310 try {
1311 try {
1312 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1313 EXPECT_TRUE(proxy_ != nullptr);
1314 proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1315 EXPECT_TRUE(false);
1316 } catch (BError &err) {
1317 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1318 }
1319
1320 try {
1321 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1322 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1323 proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1324 EXPECT_TRUE(false);
1325 } catch (BError &err) {
1326 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1327 }
1328
1329 try {
1330 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1331 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1332 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
1333 proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1334 EXPECT_TRUE(false);
1335 } catch (BError &err) {
1336 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1337 }
1338
1339 try {
1340 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1341 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1342 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
1343 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
1344 proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1345 EXPECT_TRUE(false);
1346 } catch (BError &err) {
1347 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1348 }
1349 } catch (...) {
1350 EXPECT_TRUE(false);
1351 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnBundleFinished.";
1352 }
1353 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101";
1354 }
1355
1356 /**
1357 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100
1358 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100
1359 * @tc.desc: Test function of IncrementalBackupOnAllBundlesFinished interface for SUCCESS.
1360 * @tc.size: MEDIUM
1361 * @tc.type: FUNC
1362 * @tc.level Level 1
1363 * @tc.require: I911LB
1364 */
1365 HWTEST_F(ServiceReverseProxyTest,
1366 SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100,
1367 testing::ext::TestSize.Level1)
1368 {
1369 GTEST_LOG_(INFO)
1370 << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100";
1371 try {
1372 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1373 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1374 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1375 .Times(1)
1376 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
1377 EXPECT_TRUE(proxy_ != nullptr);
1378 proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1379 EXPECT_TRUE(true);
1380 } catch (...) {
1381 EXPECT_TRUE(false);
1382 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnAllBundlesFinished.";
1383 }
1384 GTEST_LOG_(INFO)
1385 << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100";
1386 }
1387
1388 /**
1389 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0101
1390 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0101
1391 * @tc.desc: Test function of IncrementalBackupOnAllBundlesFinished interface for FAILURE.
1392 * @tc.size: MEDIUM
1393 * @tc.type: FUNC
1394 * @tc.level Level 1
1395 * @tc.require: I9OVHB
1396 */
1397 HWTEST_F(ServiceReverseProxyTest,
1398 SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0101,
1399 testing::ext::TestSize.Level1)
1400 {
1401 GTEST_LOG_(INFO)
1402 << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0101";
1403 try {
1404 try {
1405 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1406 EXPECT_TRUE(proxy_ != nullptr);
1407 proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1408 EXPECT_TRUE(false);
1409 } catch (BError &err) {
1410 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1411 }
1412
1413 try {
1414 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1415 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1416 proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1417 EXPECT_TRUE(false);
1418 } catch (BError &err) {
1419 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1420 }
1421
1422 try {
1423 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1424 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1425 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
1426 proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1427 EXPECT_TRUE(false);
1428 } catch (BError &err) {
1429 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1430 }
1431 } catch (...) {
1432 EXPECT_TRUE(false);
1433 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnAllBundlesFinished.";
1434 }
1435 GTEST_LOG_(INFO)
1436 << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0101";
1437 }
1438
1439 /**
1440 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0100
1441 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0100
1442 * @tc.desc: Test function of IncrementalRestoreOnBundleStarted interface for SUCCESS.
1443 * @tc.size: MEDIUM
1444 * @tc.type: FUNC
1445 * @tc.level Level 1
1446 * @tc.require: I911LB
1447 */
1448 HWTEST_F(ServiceReverseProxyTest,
1449 SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0100,
1450 testing::ext::TestSize.Level1)
1451 {
1452 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0100";
1453 try {
1454 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1455 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1456 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
1457 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1458 .Times(1)
1459 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
1460 EXPECT_TRUE(proxy_ != nullptr);
1461 proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1462 EXPECT_TRUE(true);
1463 } catch (...) {
1464 EXPECT_TRUE(false);
1465 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnBundleStarted.";
1466 }
1467 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0100";
1468 }
1469
1470 /**
1471 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101
1472 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101
1473 * @tc.desc: Test function of IncrementalRestoreOnBundleStarted interface for FAILURE.
1474 * @tc.size: MEDIUM
1475 * @tc.type: FUNC
1476 * @tc.level Level 1
1477 * @tc.require: I9OVHB
1478 */
1479 HWTEST_F(ServiceReverseProxyTest,
1480 SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101,
1481 testing::ext::TestSize.Level1)
1482 {
1483 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101";
1484 try {
1485 try {
1486 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1487 EXPECT_TRUE(proxy_ != nullptr);
1488 proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1489 EXPECT_TRUE(false);
1490 } catch (BError &err) {
1491 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1492 }
1493
1494 try {
1495 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1496 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1497 proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1498 EXPECT_TRUE(false);
1499 } catch (BError &err) {
1500 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1501 }
1502
1503 try {
1504 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1505 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1506 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
1507 proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1508 EXPECT_TRUE(false);
1509 } catch (BError &err) {
1510 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1511 }
1512
1513 try {
1514 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1515 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1516 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
1517 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
1518 proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1519 EXPECT_TRUE(false);
1520 } catch (BError &err) {
1521 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1522 }
1523 } catch (...) {
1524 EXPECT_TRUE(false);
1525 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnBundleStarted.";
1526 }
1527 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101";
1528 }
1529
1530 /**
1531 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100
1532 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100
1533 * @tc.desc: Test function of IncrementalRestoreOnBundleFinished interface for SUCCESS.
1534 * @tc.size: MEDIUM
1535 * @tc.type: FUNC
1536 * @tc.level Level 1
1537 * @tc.require: I911LB
1538 */
1539 HWTEST_F(ServiceReverseProxyTest,
1540 SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100,
1541 testing::ext::TestSize.Level1)
1542 {
1543 GTEST_LOG_(INFO)
1544 << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100";
1545 try {
1546 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1547 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1548 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
1549 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1550 .Times(1)
1551 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
1552 EXPECT_TRUE(proxy_ != nullptr);
1553 proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1554 EXPECT_TRUE(true);
1555 } catch (...) {
1556 EXPECT_TRUE(false);
1557 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnBundleFinished.";
1558 }
1559 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100";
1560 }
1561
1562 /**
1563 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0101
1564 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0101
1565 * @tc.desc: Test function of IncrementalRestoreOnBundleFinished interface for FAILURE.
1566 * @tc.size: MEDIUM
1567 * @tc.type: FUNC
1568 * @tc.level Level 1
1569 * @tc.require: I9OVHB
1570 */
1571 HWTEST_F(ServiceReverseProxyTest,
1572 SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0101,
1573 testing::ext::TestSize.Level1)
1574 {
1575 GTEST_LOG_(INFO)
1576 << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0101";
1577 try {
1578 try {
1579 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1580 EXPECT_TRUE(proxy_ != nullptr);
1581 proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1582 EXPECT_TRUE(false);
1583 } catch (BError &err) {
1584 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1585 }
1586
1587 try {
1588 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1589 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1590 proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1591 EXPECT_TRUE(false);
1592 } catch (BError &err) {
1593 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1594 }
1595
1596 try {
1597 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1598 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1599 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
1600 proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1601 EXPECT_TRUE(false);
1602 } catch (BError &err) {
1603 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1604 }
1605
1606 try {
1607 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1608 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1609 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
1610 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
1611 proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1612 EXPECT_TRUE(false);
1613 } catch (BError &err) {
1614 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1615 }
1616 } catch (...) {
1617 EXPECT_TRUE(false);
1618 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnBundleFinished.";
1619 }
1620 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0101";
1621 }
1622
1623 /**
1624 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0100
1625 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0100
1626 * @tc.desc: Test function of IncrementalRestoreOnAllBundlesFinished interface for SUCCESS.
1627 * @tc.size: MEDIUM
1628 * @tc.type: FUNC
1629 * @tc.level Level 1
1630 * @tc.require: I911LB
1631 */
1632 HWTEST_F(ServiceReverseProxyTest,
1633 SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0100,
1634 testing::ext::TestSize.Level1)
1635 {
1636 GTEST_LOG_(INFO)
1637 << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0100";
1638 try {
1639 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1640 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1641 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1642 .Times(1)
1643 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
1644 EXPECT_TRUE(proxy_ != nullptr);
1645 proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1646 EXPECT_TRUE(true);
1647 } catch (...) {
1648 EXPECT_TRUE(false);
1649 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished.";
1650 }
1651 GTEST_LOG_(INFO)
1652 << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0100";
1653 }
1654
1655 /**
1656 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0101
1657 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0101
1658 * @tc.desc: Test function of IncrementalRestoreOnAllBundlesFinished interface for FAILURE.
1659 * @tc.size: MEDIUM
1660 * @tc.type: FUNC
1661 * @tc.level Level 1
1662 * @tc.require: I9OVHB
1663 */
1664 HWTEST_F(ServiceReverseProxyTest,
1665 SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0101,
1666 testing::ext::TestSize.Level1)
1667 {
1668 GTEST_LOG_(INFO)
1669 << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0101";
1670 try {
1671 try {
1672 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1673 EXPECT_TRUE(proxy_ != nullptr);
1674 proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1675 EXPECT_TRUE(false);
1676 } catch (BError &err) {
1677 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1678 }
1679
1680 try {
1681 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1682 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1683 proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1684 EXPECT_TRUE(false);
1685 } catch (BError &err) {
1686 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1687 }
1688
1689 try {
1690 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1691 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1692 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
1693 proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1694 EXPECT_TRUE(false);
1695 } catch (BError &err) {
1696 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1697 }
1698 } catch (...) {
1699 EXPECT_TRUE(false);
1700 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished.";
1701 }
1702 GTEST_LOG_(INFO)
1703 << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0101";
1704 }
1705
1706 /**
1707 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0100
1708 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0100
1709 * @tc.desc: Test function of IncrementalRestoreOnFileReady interface for SUCCESS.
1710 * @tc.size: MEDIUM
1711 * @tc.type: FUNC
1712 * @tc.level Level 1
1713 * @tc.require: I911LB
1714 */
1715 HWTEST_F(ServiceReverseProxyTest,
1716 SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0100,
1717 testing::ext::TestSize.Level1)
1718 {
1719 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0100";
1720 try {
1721 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1722 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1723 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1724 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
1725 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1726 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1727 .Times(1)
1728 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
1729
1730 TestManager tm("ServiceReverseProxyTest_GetFd_0400");
1731 std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME);
1732 UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
1733 TestManager tm1("ServiceReverseProxyTest_GetFd_0401");
1734 std::string manifestFilePath = tm1.GetRootDirCurTest().append(FILE_NAME_MANIFEST);
1735 UniqueFd manifestFd(open(manifestFilePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
1736 EXPECT_TRUE(proxy_ != nullptr);
1737 proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, fd, manifestFd, 0);
1738 EXPECT_TRUE(true);
1739 } catch (...) {
1740 EXPECT_TRUE(false);
1741 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnFileReady.";
1742 }
1743 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0100";
1744 }
1745
1746 /**
1747 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0101
1748 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0101
1749 * @tc.desc: Test function of IncrementalRestoreOnFileReady interface for FAILURE.
1750 * @tc.size: MEDIUM
1751 * @tc.type: FUNC
1752 * @tc.level Level 1
1753 * @tc.require: I9OVHB
1754 */
1755 HWTEST_F(ServiceReverseProxyTest,
1756 SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0101,
1757 testing::ext::TestSize.Level1)
1758 {
1759 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0101";
1760 try {
1761 try {
1762 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1763 EXPECT_TRUE(proxy_ != nullptr);
1764 proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1765 EXPECT_TRUE(false);
1766 } catch (BError &err) {
1767 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1768 }
1769
1770 try {
1771 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1772 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
1773 proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1774 EXPECT_TRUE(false);
1775 } catch (BError &err) {
1776 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1777 }
1778
1779 try {
1780 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1781 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
1782 proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1783 EXPECT_TRUE(false);
1784 } catch (BError &err) {
1785 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1786 }
1787
1788 try {
1789 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1790 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1791 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
1792 proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1793 EXPECT_TRUE(false);
1794 } catch (BError &err) {
1795 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1796 }
1797 } catch (...) {
1798 EXPECT_TRUE(false);
1799 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnFileReady.";
1800 }
1801 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0101";
1802 }
1803
1804 /**
1805 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0102
1806 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0102
1807 * @tc.desc: Test function of IncrementalRestoreOnFileReady interface for FAILURE.
1808 * @tc.size: MEDIUM
1809 * @tc.type: FUNC
1810 * @tc.level Level 1
1811 * @tc.require: I9OVHB
1812 */
1813 HWTEST_F(ServiceReverseProxyTest,
1814 SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0102,
1815 testing::ext::TestSize.Level1)
1816 {
1817 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0102";
1818 try {
1819 try {
1820 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1821 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1822 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1823 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1824 EXPECT_TRUE(proxy_ != nullptr);
1825 proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0, 0);
1826 EXPECT_TRUE(false);
1827 } catch (BError &err) {
1828 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1829 }
1830
1831 try {
1832 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1833 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1834 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1835 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(false));
1836 proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1837 EXPECT_TRUE(false);
1838 } catch (BError &err) {
1839 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1840 }
1841
1842 try {
1843 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1844 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1845 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1846 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(false));
1847 proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1848 EXPECT_TRUE(false);
1849 } catch (BError &err) {
1850 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1851 }
1852 } catch (...) {
1853 EXPECT_TRUE(false);
1854 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnFileReady.";
1855 }
1856 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0102";
1857 }
1858
1859 /**
1860 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0103
1861 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0103
1862 * @tc.desc: Test function of IncrementalRestoreOnFileReady interface for FAILURE.
1863 * @tc.size: MEDIUM
1864 * @tc.type: FUNC
1865 * @tc.level Level 1
1866 * @tc.require: I9OVHB
1867 */
1868 HWTEST_F(ServiceReverseProxyTest,
1869 SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0103,
1870 testing::ext::TestSize.Level1)
1871 {
1872 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0103";
1873 try {
1874 try {
1875 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1876 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1877 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1878 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
1879 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1880 EXPECT_TRUE(proxy_ != nullptr);
1881 proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1882 EXPECT_TRUE(false);
1883 } catch (BError &err) {
1884 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1885 }
1886
1887 try {
1888 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1889 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1890 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
1891 EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true));
1892 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1893 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
1894 proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0);
1895 EXPECT_TRUE(false);
1896 } catch (BError &err) {
1897 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1898 }
1899 } catch (...) {
1900 EXPECT_TRUE(false);
1901 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnFileReady.";
1902 }
1903 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0103";
1904 }
1905
1906 /**
1907 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnResultReport_0100
1908 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnResultReport_0100
1909 * @tc.desc: Test function of RestoreOnResultReport interface for SUCCESS.
1910 * @tc.size: MEDIUM
1911 * @tc.type: FUNC
1912 * @tc.level Level 1
1913 * @tc.require: I6F3GV
1914 */
1915 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnResultReport_0100, testing::ext::TestSize.Level1)
1916 {
1917 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnResultReport_0100";
1918 try {
1919 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1920 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1921 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1922 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1923 .Times(1)
1924 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
1925 std::string bundleName = "app01";
1926 EXPECT_TRUE(proxy_ != nullptr);
1927 proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName);
1928 EXPECT_TRUE(true);
1929 } catch (...) {
1930 EXPECT_TRUE(false);
1931 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnResultReport.";
1932 }
1933 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnResultReport_0100";
1934 }
1935
1936 /**
1937 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnResultReport_0101
1938 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnResultReport_0101
1939 * @tc.desc: Test function of RestoreOnResultReport interface for FAILURE.
1940 * @tc.size: MEDIUM
1941 * @tc.type: FUNC
1942 * @tc.level Level 1
1943 * @tc.require: I9OVHB
1944 */
1945 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnResultReport_0101, testing::ext::TestSize.Level1)
1946 {
1947 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnResultReport_0101";
1948 try {
1949 std::string bundleName = "app01";
1950 try {
1951 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1952 EXPECT_TRUE(proxy_ != nullptr);
1953 proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName);
1954 EXPECT_TRUE(false);
1955 } catch (BError &err) {
1956 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1957 }
1958
1959 try {
1960 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1961 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
1962 proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName);
1963 EXPECT_TRUE(false);
1964 } catch (BError &err) {
1965 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1966 }
1967
1968 try {
1969 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1970 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
1971 proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName);
1972 EXPECT_TRUE(false);
1973 } catch (BError &err) {
1974 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1975 }
1976
1977 try {
1978 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1979 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1980 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1981 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
1982 proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName);
1983 EXPECT_TRUE(false);
1984 } catch (BError &err) {
1985 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
1986 }
1987 } catch (...) {
1988 EXPECT_TRUE(false);
1989 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnResultReport.";
1990 }
1991 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnResultReport_0101";
1992 }
1993
1994 /**
1995 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0100
1996 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0100
1997 * @tc.desc: Test function of IncrementalRestoreOnResultReport interface for SUCCESS.
1998 * @tc.size: MEDIUM
1999 * @tc.type: FUNC
2000 * @tc.level Level 1
2001 * @tc.require: I6F3GV
2002 */
2003 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0100,
2004 testing::ext::TestSize.Level1)
2005 {
2006 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0100";
2007 try {
2008 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2009 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2010 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
2011 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2012 .Times(1)
2013 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
2014 std::string bundleName = "app01";
2015 EXPECT_TRUE(proxy_ != nullptr);
2016 proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName);
2017 EXPECT_TRUE(true);
2018 } catch (...) {
2019 EXPECT_TRUE(false);
2020 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnResultReport.";
2021 }
2022 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0100";
2023 }
2024
2025 /**
2026 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0101
2027 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0101
2028 * @tc.desc: Test function of IncrementalRestoreOnResultReport interface for FAILURE.
2029 * @tc.size: MEDIUM
2030 * @tc.type: FUNC
2031 * @tc.level Level 1
2032 * @tc.require: I9OVHB
2033 */
2034 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0101,
2035 testing::ext::TestSize.Level1)
2036 {
2037 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0101";
2038 try {
2039 std::string bundleName = "app01";
2040 try {
2041 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
2042 EXPECT_TRUE(proxy_ != nullptr);
2043 proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName);
2044 EXPECT_TRUE(false);
2045 } catch (BError &err) {
2046 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2047 }
2048
2049 try {
2050 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2051 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
2052 proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName);
2053 EXPECT_TRUE(false);
2054 } catch (BError &err) {
2055 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2056 }
2057
2058 try {
2059 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2060 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
2061 proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName);
2062 EXPECT_TRUE(false);
2063 } catch (BError &err) {
2064 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2065 }
2066
2067 try {
2068 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2069 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2070 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
2071 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
2072 proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName);
2073 EXPECT_TRUE(false);
2074 } catch (BError &err) {
2075 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2076 }
2077 } catch (...) {
2078 EXPECT_TRUE(false);
2079 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnResultReport.";
2080 }
2081 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0101";
2082 }
2083
2084 /**
2085 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0100
2086 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0100
2087 * @tc.desc: Test function of IncrementalBackupOnResultReport interface for FAILURE.
2088 * @tc.size: MEDIUM
2089 * @tc.type: FUNC
2090 * @tc.level Level 1
2091 * @tc.require: I9OVHB
2092 */
2093 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0100,
2094 testing::ext::TestSize.Level1)
2095 {
2096 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0100";
2097 try {
2098 std::string bundleName = "app01";
2099 try {
2100 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
2101 EXPECT_TRUE(proxy_ != nullptr);
2102 proxy_->IncrementalBackupOnResultReport(RESULT_REPORT, bundleName);
2103 EXPECT_TRUE(false);
2104 } catch (BError &err) {
2105 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2106 }
2107
2108 try {
2109 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2110 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
2111 proxy_->IncrementalBackupOnResultReport(RESULT_REPORT, bundleName);
2112 EXPECT_TRUE(false);
2113 } catch (BError &err) {
2114 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2115 }
2116
2117 try {
2118 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2119 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
2120 proxy_->IncrementalBackupOnResultReport(RESULT_REPORT, bundleName);
2121 EXPECT_TRUE(false);
2122 } catch (BError &err) {
2123 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2124 }
2125
2126 try {
2127 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2128 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2129 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
2130 proxy_->IncrementalBackupOnResultReport(RESULT_REPORT, bundleName);
2131 EXPECT_TRUE(false);
2132 } catch (BError &err) {
2133 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2134 }
2135 } catch (...) {
2136 EXPECT_TRUE(false);
2137 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnResultReport.";
2138 }
2139 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0100";
2140 }
2141
2142 /**
2143 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0101
2144 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0101
2145 * @tc.desc: Test function of IncrementalBackupOnResultReport interface for SUCCESS.
2146 * @tc.size: MEDIUM
2147 * @tc.type: FUNC
2148 * @tc.level Level 1
2149 * @tc.require: I6F3GV
2150 */
2151 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0101,
2152 testing::ext::TestSize.Level1)
2153 {
2154 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0101";
2155 try {
2156 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2157 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2158 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2159 .Times(1)
2160 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
2161 std::string bundleName = "app01";
2162 EXPECT_TRUE(proxy_ != nullptr);
2163 proxy_->IncrementalBackupOnResultReport(RESULT_REPORT, bundleName);
2164 EXPECT_TRUE(true);
2165 } catch (...) {
2166 EXPECT_TRUE(false);
2167 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnResultReport.";
2168 }
2169 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0101";
2170 }
2171
2172 /**
2173 * @tc.number: SUB_ServiceReverse_proxy_BackupOnProcessInfo_0100
2174 * @tc.name: SUB_ServiceReverse_proxy_BackupOnProcessInfo_0100
2175 * @tc.desc: Test function of BackupOnProcessInfo interface for SUCCESS.
2176 * @tc.size: MEDIUM
2177 * @tc.type: FUNC
2178 * @tc.level Level 1
2179 * @tc.require: I6F3GV
2180 */
2181 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnProcessInfo_0100, testing::ext::TestSize.Level1)
2182 {
2183 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnProcessInfo_0100";
2184 try {
2185 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2186 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2187 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2188 .Times(1)
2189 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
2190 EXPECT_TRUE(proxy_ != nullptr);
2191 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
2192 proxy_->BackupOnProcessInfo(BUNDLE_NAME, processInfo);
2193 EXPECT_TRUE(true);
2194 } catch (...) {
2195 EXPECT_TRUE(false);
2196 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnProcessInfo.";
2197 }
2198 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnProcessInfo_0100";
2199 }
2200
2201 /**
2202 * @tc.number: SUB_ServiceReverse_proxy_BackupOnProcessInfo_0101
2203 * @tc.name: SUB_ServiceReverse_proxy_BackupOnProcessInfo_0101
2204 * @tc.desc: Test function of BackupOnProcessInfo interface for FAILURE.
2205 * @tc.size: MEDIUM
2206 * @tc.type: FUNC
2207 * @tc.level Level 1
2208 * @tc.require: I6F3GV
2209 */
2210 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnProcessInfo_0101, testing::ext::TestSize.Level1)
2211 {
2212 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnProcessInfo_0101";
2213 try {
2214 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
2215 try {
2216 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
2217 EXPECT_TRUE(proxy_ != nullptr);
2218 proxy_->BackupOnProcessInfo(BUNDLE_NAME, processInfo);
2219 EXPECT_TRUE(false);
2220 } catch (BError &err) {
2221 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2222 }
2223
2224 try {
2225 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2226 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
2227 EXPECT_TRUE(proxy_ != nullptr);
2228 proxy_->BackupOnProcessInfo(BUNDLE_NAME, processInfo);
2229 EXPECT_TRUE(false);
2230 } catch (BError &err) {
2231 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2232 }
2233
2234 try {
2235 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2236 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
2237 EXPECT_TRUE(proxy_ != nullptr);
2238 proxy_->BackupOnProcessInfo(BUNDLE_NAME, processInfo);
2239 EXPECT_TRUE(false);
2240 } catch (BError &err) {
2241 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2242 }
2243
2244 try {
2245 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2246 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2247 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
2248 proxy_->BackupOnProcessInfo(BUNDLE_NAME, processInfo);
2249 EXPECT_TRUE(false);
2250 } catch (BError &err) {
2251 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2252 }
2253 } catch (...) {
2254 EXPECT_TRUE(false);
2255 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnProcessInfo.";
2256 }
2257 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnProcessInfo_0101";
2258 }
2259
2260 /**
2261 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0100
2262 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0100
2263 * @tc.desc: Test function of RestoreOnProcessInfo interface for SUCCESS.
2264 * @tc.size: MEDIUM
2265 * @tc.type: FUNC
2266 * @tc.level Level 1
2267 * @tc.require: I6F3GV
2268 */
2269 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0100, testing::ext::TestSize.Level1)
2270 {
2271 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0100";
2272 try {
2273 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2274 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2275 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2276 .Times(1)
2277 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
2278 EXPECT_TRUE(proxy_ != nullptr);
2279 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
2280 proxy_->RestoreOnProcessInfo(BUNDLE_NAME, processInfo);
2281 EXPECT_TRUE(true);
2282 } catch (...) {
2283 EXPECT_TRUE(false);
2284 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnProcessInfo.";
2285 }
2286 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0100";
2287 }
2288
2289 /**
2290 * @tc.number: SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0101
2291 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0101
2292 * @tc.desc: Test function of RestoreOnProcessInfo interface for FAILURE.
2293 * @tc.size: MEDIUM
2294 * @tc.type: FUNC
2295 * @tc.level Level 1
2296 * @tc.require: I6F3GV
2297 */
2298 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0101, testing::ext::TestSize.Level1)
2299 {
2300 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0101";
2301 try {
2302 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
2303 try {
2304 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
2305 EXPECT_TRUE(proxy_ != nullptr);
2306 proxy_->RestoreOnProcessInfo(BUNDLE_NAME, processInfo);
2307 EXPECT_TRUE(false);
2308 } catch (BError &err) {
2309 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2310 }
2311
2312 try {
2313 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2314 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
2315 EXPECT_TRUE(proxy_ != nullptr);
2316 proxy_->RestoreOnProcessInfo(BUNDLE_NAME, processInfo);
2317 EXPECT_TRUE(false);
2318 } catch (BError &err) {
2319 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2320 }
2321
2322 try {
2323 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2324 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
2325 EXPECT_TRUE(proxy_ != nullptr);
2326 proxy_->RestoreOnProcessInfo(BUNDLE_NAME, processInfo);
2327 EXPECT_TRUE(false);
2328 } catch (BError &err) {
2329 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2330 }
2331
2332 try {
2333 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2334 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2335 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
2336 proxy_->RestoreOnProcessInfo(BUNDLE_NAME, processInfo);
2337 EXPECT_TRUE(false);
2338 } catch (BError &err) {
2339 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2340 }
2341 } catch (...) {
2342 EXPECT_TRUE(false);
2343 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnProcessInfo.";
2344 }
2345 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0101";
2346 }
2347
2348 /**
2349 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0100
2350 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0100
2351 * @tc.desc: Test function of IncrementalBackupOnProcessInfo interface for SUCCESS.
2352 * @tc.size: MEDIUM
2353 * @tc.type: FUNC
2354 * @tc.level Level 1
2355 * @tc.require: I6F3GV
2356 */
2357 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0100,
2358 testing::ext::TestSize.Level1)
2359 {
2360 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0100";
2361 try {
2362 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2363 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2364 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2365 .Times(1)
2366 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
2367 EXPECT_TRUE(proxy_ != nullptr);
2368 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
2369 proxy_->IncrementalBackupOnProcessInfo(BUNDLE_NAME, processInfo);
2370 EXPECT_TRUE(true);
2371 } catch (...) {
2372 EXPECT_TRUE(false);
2373 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnProcessInfo.";
2374 }
2375 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0100";
2376 }
2377
2378 /**
2379 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0101
2380 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0101
2381 * @tc.desc: Test function of IncrementalBackupOnProcessInfo interface for FAILURE.
2382 * @tc.size: MEDIUM
2383 * @tc.type: FUNC
2384 * @tc.level Level 1
2385 * @tc.require: I6F3GV
2386 */
2387 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0101,
2388 testing::ext::TestSize.Level1)
2389 {
2390 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0101";
2391 try {
2392 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
2393 try {
2394 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
2395 EXPECT_TRUE(proxy_ != nullptr);
2396 proxy_->IncrementalBackupOnProcessInfo(BUNDLE_NAME, processInfo);
2397 EXPECT_TRUE(false);
2398 } catch (BError &err) {
2399 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2400 }
2401
2402 try {
2403 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2404 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
2405 EXPECT_TRUE(proxy_ != nullptr);
2406 proxy_->IncrementalBackupOnProcessInfo(BUNDLE_NAME, processInfo);
2407 EXPECT_TRUE(false);
2408 } catch (BError &err) {
2409 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2410 }
2411
2412 try {
2413 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2414 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
2415 EXPECT_TRUE(proxy_ != nullptr);
2416 proxy_->IncrementalBackupOnProcessInfo(BUNDLE_NAME, processInfo);
2417 EXPECT_TRUE(false);
2418 } catch (BError &err) {
2419 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2420 }
2421
2422 try {
2423 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2424 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2425 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
2426 proxy_->IncrementalBackupOnProcessInfo(BUNDLE_NAME, processInfo);
2427 EXPECT_TRUE(false);
2428 } catch (BError &err) {
2429 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2430 }
2431 } catch (...) {
2432 EXPECT_TRUE(false);
2433 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnProcessInfo.";
2434 }
2435 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0101";
2436 }
2437
2438 /**
2439 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0100
2440 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0100
2441 * @tc.desc: Test function of IncrementalRestoreOnProcessInfo interface for SUCCESS.
2442 * @tc.size: MEDIUM
2443 * @tc.type: FUNC
2444 * @tc.level Level 1
2445 * @tc.require: I6F3GV
2446 */
2447 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0100,
2448 testing::ext::TestSize.Level1)
2449 {
2450 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0100";
2451 try {
2452 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2453 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2454 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2455 .Times(1)
2456 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
2457 EXPECT_TRUE(proxy_ != nullptr);
2458 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
2459 proxy_->IncrementalRestoreOnProcessInfo(BUNDLE_NAME, processInfo);
2460 EXPECT_TRUE(true);
2461 } catch (...) {
2462 EXPECT_TRUE(false);
2463 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnProcessInfo.";
2464 }
2465 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0100";
2466 }
2467
2468 /**
2469 * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0101
2470 * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0101
2471 * @tc.desc: Test function of IncrementalRestoreOnProcessInfo interface for FAILURE.
2472 * @tc.size: MEDIUM
2473 * @tc.type: FUNC
2474 * @tc.level Level 1
2475 * @tc.require: I6F3GV
2476 */
2477 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0101,
2478 testing::ext::TestSize.Level1)
2479 {
2480 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0101";
2481 try {
2482 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
2483 try {
2484 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
2485 EXPECT_TRUE(proxy_ != nullptr);
2486 proxy_->IncrementalRestoreOnProcessInfo(BUNDLE_NAME, processInfo);
2487 EXPECT_TRUE(false);
2488 } catch (BError &err) {
2489 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2490 }
2491
2492 try {
2493 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2494 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
2495 EXPECT_TRUE(proxy_ != nullptr);
2496 proxy_->IncrementalRestoreOnProcessInfo(BUNDLE_NAME, processInfo);
2497 EXPECT_TRUE(false);
2498 } catch (BError &err) {
2499 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2500 }
2501
2502 try {
2503 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2504 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
2505 EXPECT_TRUE(proxy_ != nullptr);
2506 proxy_->IncrementalRestoreOnProcessInfo(BUNDLE_NAME, processInfo);
2507 EXPECT_TRUE(false);
2508 } catch (BError &err) {
2509 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2510 }
2511
2512 try {
2513 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2514 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
2515 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
2516 proxy_->IncrementalRestoreOnProcessInfo(BUNDLE_NAME, processInfo);
2517 EXPECT_TRUE(false);
2518 } catch (BError &err) {
2519 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2520 }
2521 } catch (...) {
2522 EXPECT_TRUE(false);
2523 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnProcessInfo.";
2524 }
2525 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0101";
2526 }
2527
2528 /**
2529 * @tc.number: SUB_ServiceReverse_proxy_BackupOnScanningInfo_0100
2530 * @tc.name: SUB_ServiceReverse_proxy_BackupOnScanningInfo_0100
2531 * @tc.desc: Test function of BackupOnScanningInfo interface for SUCCESS.
2532 * @tc.size: MEDIUM
2533 * @tc.type: FUNC
2534 * @tc.level Level 1
2535 * @tc.require: I6F3GV
2536 */
2537 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnScanningInfo_0100, testing::ext::TestSize.Level1)
2538 {
2539 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnScanningInfo_0100";
2540 try {
2541 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2542 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
2543 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2544 .Times(1)
2545 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
2546 EXPECT_TRUE(proxy_ != nullptr);
2547 std::string scannedInfo;
2548 proxy_->BackupOnScanningInfo(scannedInfo);
2549 EXPECT_TRUE(true);
2550 } catch (...) {
2551 EXPECT_TRUE(false);
2552 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnScanningInfo.";
2553 }
2554 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnScanningInfo_0100";
2555 }
2556
2557 /**
2558 * @tc.number: SUB_ServiceReverse_proxy_BackupOnScanningInfo_0101
2559 * @tc.name: SUB_ServiceReverse_proxy_BackupOnScanningInfo_0101
2560 * @tc.desc: Test function of BackupOnScanningInfo interface for FAILURE.
2561 * @tc.size: MEDIUM
2562 * @tc.type: FUNC
2563 * @tc.level Level 1
2564 * @tc.require: I6F3GV
2565 */
2566 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnScanningInfo_0101,
2567 testing::ext::TestSize.Level1)
2568 {
2569 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnScanningInfo_0101";
2570 try {
2571 std::string scannedInfo;
2572 try {
2573 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
2574 EXPECT_TRUE(proxy_ != nullptr);
2575 proxy_->BackupOnScanningInfo(scannedInfo);
2576 EXPECT_TRUE(false);
2577 } catch (BError &err) {
2578 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2579 }
2580
2581 try {
2582 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2583 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
2584 EXPECT_TRUE(proxy_ != nullptr);
2585 proxy_->BackupOnScanningInfo(scannedInfo);
2586 EXPECT_TRUE(false);
2587 } catch (BError &err) {
2588 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2589 }
2590
2591 try {
2592 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2593 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
2594 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
2595 proxy_->BackupOnScanningInfo(scannedInfo);
2596 EXPECT_TRUE(false);
2597 } catch (BError &err) {
2598 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2599 }
2600 } catch (...) {
2601 EXPECT_TRUE(false);
2602 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnScanningInfo.";
2603 }
2604 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnScanningInfo_0101";
2605 }
2606
2607 /**
2608 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0100
2609 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0100
2610 * @tc.desc: Test function of IncrementalBackupOnScanningInfo interface for SUCCESS.
2611 * @tc.size: MEDIUM
2612 * @tc.type: FUNC
2613 * @tc.level Level 1
2614 * @tc.require: I6F3GV
2615 */
2616 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0100,
2617 testing::ext::TestSize.Level1)
2618 {
2619 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0100";
2620 try {
2621 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2622 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
2623 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2624 .Times(1)
2625 .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest));
2626 EXPECT_TRUE(proxy_ != nullptr);
2627 std::string scannedInfo;
2628 proxy_->IncrementalBackupOnScanningInfo(scannedInfo);
2629 EXPECT_TRUE(true);
2630 } catch (...) {
2631 EXPECT_TRUE(false);
2632 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnScanningInfo.";
2633 }
2634 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0100";
2635 }
2636
2637 /**
2638 * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0101
2639 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0101
2640 * @tc.desc: Test function of IncrementalBackupOnScanningInfo interface for FAILURE.
2641 * @tc.size: MEDIUM
2642 * @tc.type: FUNC
2643 * @tc.level Level 1
2644 * @tc.require: I6F3GV
2645 */
2646 HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0101,
2647 testing::ext::TestSize.Level1)
2648 {
2649 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0101";
2650 try {
2651 std::string scannedInfo;
2652 try {
2653 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
2654 EXPECT_TRUE(proxy_ != nullptr);
2655 proxy_->IncrementalBackupOnScanningInfo(scannedInfo);
2656 EXPECT_TRUE(false);
2657 } catch (BError &err) {
2658 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2659 }
2660
2661 try {
2662 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2663 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
2664 EXPECT_TRUE(proxy_ != nullptr);
2665 proxy_->IncrementalBackupOnScanningInfo(scannedInfo);
2666 EXPECT_TRUE(false);
2667 } catch (BError &err) {
2668 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2669 }
2670
2671 try {
2672 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
2673 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
2674 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1));
2675 proxy_->IncrementalBackupOnScanningInfo(scannedInfo);
2676 EXPECT_TRUE(false);
2677 } catch (BError &err) {
2678 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC);
2679 }
2680 } catch (...) {
2681 EXPECT_TRUE(false);
2682 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnScanningInfo.";
2683 }
2684 GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0101";
2685 }
2686 } // namespace OHOS::FileManagement::Backup