1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "distributed_file_daemon_proxy.h"
16 
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 
20 #include "dfs_error.h"
21 #include "file_dfs_listener_mock.h"
22 #include "message_parcel_mock.h"
23 #include "i_daemon_mock.h"
24 
25 namespace OHOS::Storage::DistributedFile::Test {
26 using namespace OHOS::FileManagement;
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace std;
30 
31 class DistributedFileDaemonProxyTest : public testing::Test {
32 public:
33     static void SetUpTestCase(void);
34     static void TearDownTestCase(void);
35     void SetUp();
36     void TearDown();
37 public:
38     static inline shared_ptr<DistributedFileDaemonProxy> proxy_ = nullptr;
39     static inline sptr<DaemonServiceMock> mock_ = nullptr;
40     static inline shared_ptr<MessageParcelMock> messageParcelMock_ = nullptr;
41 };
42 
SetUpTestCase(void)43 void DistributedFileDaemonProxyTest::SetUpTestCase(void)
44 {
45     GTEST_LOG_(INFO) << "SetUpTestCase";
46     mock_ = sptr(new DaemonServiceMock());
47     proxy_ = make_shared<DistributedFileDaemonProxy>(mock_);
48     messageParcelMock_ = make_shared<MessageParcelMock>();
49     MessageParcelMock::messageParcel = messageParcelMock_;
50 }
51 
TearDownTestCase(void)52 void DistributedFileDaemonProxyTest::TearDownTestCase(void)
53 {
54     GTEST_LOG_(INFO) << "TearDownTestCase";
55     mock_ = nullptr;
56     proxy_ = nullptr;
57     MessageParcelMock::messageParcel = nullptr;
58     messageParcelMock_ = nullptr;
59 }
60 
SetUp(void)61 void DistributedFileDaemonProxyTest::SetUp(void)
62 {
63     GTEST_LOG_(INFO) << "SetUp";
64 }
65 
TearDown(void)66 void DistributedFileDaemonProxyTest::TearDown(void)
67 {
68     GTEST_LOG_(INFO) << "TearDown";
69 }
70 
71 /**
72  * @tc.name: DistributedFileDaemon_OpenP2PConnection_0100
73  * @tc.desc: The execution of the OpenP2PConnection failed.
74  * @tc.type: FUNC
75  * @tc.require: I7TDJK
76  */
77 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_OpenP2PConnection_0100, TestSize.Level1)
78 {
79     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0100 Start";
80     DistributedHardware::DmDeviceInfo deviceInfo;
81     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
82     auto ret = proxy_->OpenP2PConnection(deviceInfo);
83     EXPECT_EQ(ret, E_BROKEN_IPC);
84 
85     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
86     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(false));
87     ret = proxy_->OpenP2PConnection(deviceInfo);
88     EXPECT_EQ(ret, E_INVAL_ARG);
89 
90     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
91     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
92         .WillOnce(Return(false));
93     ret = proxy_->OpenP2PConnection(deviceInfo);
94     EXPECT_EQ(ret, E_INVAL_ARG);
95 
96     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
97     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
98         .WillOnce(Return(true)).WillOnce(Return(false));
99     ret = proxy_->OpenP2PConnection(deviceInfo);
100     EXPECT_EQ(ret, E_INVAL_ARG);
101 
102     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
103     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
104         .WillOnce(Return(true)).WillOnce(Return(true));
105     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(false));
106     ret = proxy_->OpenP2PConnection(deviceInfo);
107     EXPECT_EQ(ret, E_INVAL_ARG);
108     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0100 End";
109 }
110 
111 /**
112  * @tc.name: DistributedFileDaemon_OpenP2PConnection_0200
113  * @tc.desc: The execution of the OpenP2PConnection failed.
114  * @tc.type: FUNC
115  * @tc.require: I7TDJK
116  */
117 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_OpenP2PConnection_0200, TestSize.Level1)
118 {
119     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0200 Start";
120     DistributedHardware::DmDeviceInfo deviceInfo;
121     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
122     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
123         .WillOnce(Return(true)).WillOnce(Return(true));
124     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(true));
125     EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(false));
126     auto ret = proxy_->OpenP2PConnection(deviceInfo);
127     EXPECT_EQ(ret, E_INVAL_ARG);
128 
129     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
130     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
131         .WillOnce(Return(true)).WillOnce(Return(true));
132     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(true));
133     EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(true));
134     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
135     ret = proxy_->OpenP2PConnection(deviceInfo);
136     EXPECT_EQ(ret, E_INVAL_ARG);
137     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0200 End";
138 }
139 
140 /**
141  * @tc.name: DistributedFileDaemon_OpenP2PConnection_0300
142  * @tc.desc: The execution of the OpenP2PConnection failed.
143  * @tc.type: FUNC
144  * @tc.require: I7TDJK
145  */
146 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_OpenP2PConnection_0300, TestSize.Level1)
147 {
148     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0300 Start";
149     DistributedHardware::DmDeviceInfo deviceInfo;
150     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
151     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
152         .WillOnce(Return(true)).WillOnce(Return(true));
153     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(true));
154     EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(true));
155     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
156     auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
157     auto ret = testProxy->OpenP2PConnection(deviceInfo);
158     EXPECT_EQ(ret, E_BROKEN_IPC);
159     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0300 End";
160 }
161 
162 /**
163  * @tc.name: DistributedFileDaemon_OpenP2PConnection_0400
164  * @tc.desc: The execution of the OpenP2PConnection failed.
165  * @tc.type: FUNC
166  * @tc.require: I7TDJK
167  */
168 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_OpenP2PConnection_0400, TestSize.Level1)
169 {
170     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0400 Start";
171     DistributedHardware::DmDeviceInfo deviceInfo;
172     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
173     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
174         .WillOnce(Return(true)).WillOnce(Return(true));
175     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(true));
176     EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(true));
177     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
178     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
179     auto ret = proxy_->OpenP2PConnection(deviceInfo);
180     EXPECT_EQ(ret, E_BROKEN_IPC);
181     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0400 End";
182 }
183 
184 /**
185  * @tc.name: DistributedFileDaemon_OpenP2PConnection_0500
186  * @tc.desc: The execution of the OpenP2PConnection success.
187  * @tc.type: FUNC
188  * @tc.require: I7TDJK
189  */
190 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_OpenP2PConnection_0500, TestSize.Level1)
191 {
192     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0500 Start";
193     DistributedHardware::DmDeviceInfo deviceInfo;
194     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
195     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
196         .WillOnce(Return(true)).WillOnce(Return(true));
197     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(true));
198     EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(true));
199     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
200     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
201     EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
202     auto ret = proxy_->OpenP2PConnection(deviceInfo);
203     EXPECT_EQ(ret, E_INVAL_ARG);
204     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0500 End";
205 }
206 
207 /**
208  * @tc.name: DistributedFileDaemon_CloseP2PConnection_0100
209  * @tc.desc: The execution of the CloseP2PConnection failed.
210  * @tc.type: FUNC
211  * @tc.require: I7TDJK
212  */
213 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CloseP2PConnection_0100, TestSize.Level1)
214 {
215     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0100 Start";
216     DistributedHardware::DmDeviceInfo deviceInfo;
217     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
218     auto ret = proxy_->OpenP2PConnection(deviceInfo);
219     EXPECT_EQ(ret, E_BROKEN_IPC);
220 
221     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
222     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(false));
223     ret = proxy_->CloseP2PConnection(deviceInfo);
224     EXPECT_EQ(ret, E_INVAL_ARG);
225 
226     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
227     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
228         .WillOnce(Return(false));
229     ret = proxy_->CloseP2PConnection(deviceInfo);
230     EXPECT_EQ(ret, E_INVAL_ARG);
231 
232     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
233     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
234         .WillOnce(Return(true)).WillOnce(Return(false));
235     ret = proxy_->CloseP2PConnection(deviceInfo);
236     EXPECT_EQ(ret, E_INVAL_ARG);
237 
238     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
239     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
240         .WillOnce(Return(true)).WillOnce(Return(true));
241     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(false));
242     ret = proxy_->CloseP2PConnection(deviceInfo);
243     EXPECT_EQ(ret, E_INVAL_ARG);
244     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0100 End";
245 }
246 
247 /**
248  * @tc.name: DistributedFileDaemon_CloseP2PConnection_0200
249  * @tc.desc: The execution of the CloseP2PConnection failed.
250  * @tc.type: FUNC
251  * @tc.require: I7TDJK
252  */
253 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CloseP2PConnection_0200, TestSize.Level1)
254 {
255     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0200 Start";
256     DistributedHardware::DmDeviceInfo deviceInfo;
257     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
258     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
259         .WillOnce(Return(true)).WillOnce(Return(true));
260     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(true));
261     EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(false));
262     auto ret = proxy_->CloseP2PConnection(deviceInfo);
263     EXPECT_EQ(ret, E_INVAL_ARG);
264 
265     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
266     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
267         .WillOnce(Return(true)).WillOnce(Return(true));
268     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(true));
269     EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(true));
270     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
271     ret = proxy_->CloseP2PConnection(deviceInfo);
272     EXPECT_EQ(ret, E_INVAL_ARG);
273     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0200 End";
274 }
275 
276 /**
277  * @tc.name: DistributedFileDaemon_CloseP2PConnection_0300
278  * @tc.desc: The execution of the CloseP2PConnection failed.
279  * @tc.type: FUNC
280  * @tc.require: I7TDJK
281  */
282 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CloseP2PConnection_0300, TestSize.Level1)
283 {
284     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0300 Start";
285     DistributedHardware::DmDeviceInfo deviceInfo;
286     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
287     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
288         .WillOnce(Return(true)).WillOnce(Return(true));
289     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(true));
290     EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(true));
291     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
292     auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
293     auto ret = testProxy->CloseP2PConnection(deviceInfo);
294     EXPECT_EQ(ret, E_BROKEN_IPC);
295     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0300 End";
296 }
297 
298 /**
299  * @tc.name: DistributedFileDaemon_CloseP2PConnection_0400
300  * @tc.desc: The execution of the CloseP2PConnection failed.
301  * @tc.type: FUNC
302  * @tc.require: I7TDJK
303  */
304 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CloseP2PConnection_0400, TestSize.Level1)
305 {
306     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0400 Start";
307     DistributedHardware::DmDeviceInfo deviceInfo;
308     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
309     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
310         .WillOnce(Return(true)).WillOnce(Return(true));
311     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(true));
312     EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(true));
313     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
314     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
315     auto ret = proxy_->CloseP2PConnection(deviceInfo);
316     EXPECT_EQ(ret, E_BROKEN_IPC);
317     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0400 End";
318 }
319 
320 /**
321  * @tc.name: DistributedFileDaemon_CloseP2PConnection_0500
322  * @tc.desc: The execution of the CloseP2PConnection success.
323  * @tc.type: FUNC
324  * @tc.require: I7TDJK
325  */
326 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CloseP2PConnection_0500, TestSize.Level1)
327 {
328     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0500 Start";
329     DistributedHardware::DmDeviceInfo deviceInfo;
330     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
331     EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
332         .WillOnce(Return(true)).WillOnce(Return(true));
333     EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(true));
334     EXPECT_CALL(*messageParcelMock_, WriteUint32(_)).WillOnce(Return(true));
335     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
336     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
337     EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
338     auto ret = proxy_->CloseP2PConnection(deviceInfo);
339     EXPECT_EQ(ret, E_INVAL_ARG);
340     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0500 End";
341 }
342 
343 /**
344  * @tc.name: DistributedFileDaemon_OpenP2PConnectionEx_0100
345  * @tc.desc: verify OpenP2PConnectionEx
346  * @tc.type: FUNC
347  * @tc.require: I7TDJK
348  */
349 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_OpenP2PConnectionEx_0100, TestSize.Level1)
350 {
351     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnectionEx_0100 Start";
352     auto remoteReverseObj = sptr(new FileDfsListenerMock());
353     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
354     auto ret = proxy_->OpenP2PConnectionEx("test", remoteReverseObj);
355     EXPECT_EQ(ret, E_BROKEN_IPC);
356 
357     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
358     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
359     ret = proxy_->OpenP2PConnectionEx("test", remoteReverseObj);
360     EXPECT_EQ(ret, E_INVAL_ARG);
361 
362     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
363     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
364     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
365         .WillOnce(Return(false));
366     ret = proxy_->OpenP2PConnectionEx("test", remoteReverseObj);
367     EXPECT_EQ(ret, E_BROKEN_IPC);
368 
369     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
370     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
371     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
372         .WillOnce(Return(true));
373     auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
374     ret = testProxy->OpenP2PConnectionEx("test", remoteReverseObj);
375     EXPECT_EQ(ret, E_BROKEN_IPC);
376     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnectionEx_0100 End";
377 }
378 
379 /**
380  * @tc.name: DistributedFileDaemon_OpenP2PConnectionEx_0200
381  * @tc.desc: verify OpenP2PConnectionEx
382  * @tc.type: FUNC
383  * @tc.require: I7TDJK
384  */
385 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_OpenP2PConnectionEx_0200, TestSize.Level1)
386 {
387     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnectionEx_0200 Start";
388     auto remoteReverseObj = sptr(new FileDfsListenerMock());
389     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
390     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
391     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
392         .WillOnce(Return(true));
393     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
394     auto ret = proxy_->OpenP2PConnectionEx("test", remoteReverseObj);
395     EXPECT_EQ(ret, E_BROKEN_IPC);
396 
397     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
398     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
399     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
400         .WillOnce(Return(true));
401     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
402     EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
403     ret = proxy_->OpenP2PConnectionEx("test", remoteReverseObj);
404     EXPECT_EQ(ret, E_INVAL_ARG);
405     GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnectionEx_0200 End";
406 }
407 
408 /**
409  * @tc.name: DistributedFileDaemon_CloseP2PConnectionEx_0100
410  * @tc.desc: verify CloseP2PConnectionEx
411  * @tc.type: FUNC
412  * @tc.require: I7TDJK
413  */
414 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CloseP2PConnectionEx_0100, TestSize.Level1)
415 {
416     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnectionEx_0100 Start";
417     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
418     auto ret = proxy_->CloseP2PConnectionEx("test");
419     EXPECT_EQ(ret, E_BROKEN_IPC);
420 
421     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
422     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
423     ret = proxy_->CloseP2PConnectionEx("test");
424     EXPECT_EQ(ret, E_INVAL_ARG);
425 
426     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
427     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
428     auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
429     ret = testProxy->CloseP2PConnectionEx("test");
430     EXPECT_EQ(ret, E_BROKEN_IPC);
431     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnectionEx_0100 End";
432 }
433 
434 /**
435  * @tc.name: DistributedFileDaemon_CloseP2PConnectionEx_0200
436  * @tc.desc: verify CloseP2PConnectionEx
437  * @tc.type: FUNC
438  * @tc.require: I7TDJK
439  */
440 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CloseP2PConnectionEx_0200, TestSize.Level1)
441 {
442     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnectionEx_0200 Start";
443     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
444     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
445     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
446     auto ret = proxy_->CloseP2PConnectionEx("test");
447     EXPECT_EQ(ret, E_BROKEN_IPC);
448 
449     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
450     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
451     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
452     EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
453     ret = proxy_->CloseP2PConnectionEx("test");
454     EXPECT_EQ(ret, E_INVAL_ARG);
455     GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnectionEx_0200 End";
456 }
457 
458 /**
459  * @tc.name: DistributedFileDaemon_PrepareSession_0100
460  * @tc.desc: verify PrepareSession
461  * @tc.type: FUNC
462  * @tc.require: I7TDJK
463  */
464 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_PrepareSession_0100, TestSize.Level1)
465 {
466     GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0100 Start";
467     auto remoteReverseObj = sptr(new FileDfsListenerMock());
468     HmdfsInfo fileInfo;
469     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
470     auto ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
471         remoteReverseObj->AsObject(), fileInfo);
472     EXPECT_EQ(ret, E_BROKEN_IPC);
473 
474     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
475     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
476     ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
477         remoteReverseObj->AsObject(), fileInfo);
478     EXPECT_EQ(ret, E_INVAL_ARG);
479 
480     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
481     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
482     ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
483         remoteReverseObj->AsObject(), fileInfo);
484     EXPECT_EQ(ret, E_INVAL_ARG);
485 
486     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
487     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
488         .WillOnce(Return(false));
489     ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
490         remoteReverseObj->AsObject(), fileInfo);
491     EXPECT_EQ(ret, E_INVAL_ARG);
492     GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0100 End";
493 }
494 
495 /**
496  * @tc.name: DistributedFileDaemon_PrepareSession_0200
497  * @tc.desc: verify PrepareSession
498  * @tc.type: FUNC
499  * @tc.require: I7TDJK
500  */
501 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_PrepareSession_0200, TestSize.Level1)
502 {
503     GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0200 Start";
504     auto remoteReverseObj = sptr(new FileDfsListenerMock());
505     HmdfsInfo fileInfo;
506     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
507     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
508         .WillOnce(Return(true));
509     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
510         .WillOnce(Return(false));
511     auto ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
512         remoteReverseObj->AsObject(), fileInfo);
513     EXPECT_EQ(ret, E_INVAL_ARG);
514 
515     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
516     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
517         .WillOnce(Return(true)).WillOnce(Return(false));
518     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
519         .WillOnce(Return(true));
520     ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
521         remoteReverseObj->AsObject(), fileInfo);
522     EXPECT_EQ(ret, E_INVAL_ARG);
523 
524     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
525     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
526         .WillOnce(Return(true)).WillOnce(Return(true));
527     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
528         .WillOnce(Return(true));
529     EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
530     ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
531         remoteReverseObj->AsObject(), fileInfo);
532     EXPECT_EQ(ret, E_INVAL_ARG);
533 
534     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
535     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
536         .WillOnce(Return(true)).WillOnce(Return(true));
537     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
538         .WillOnce(Return(true));
539     EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
540     auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
541     ret = testProxy->PrepareSession("srcUri", "dstUri", "deviceId",
542         remoteReverseObj->AsObject(), fileInfo);
543     EXPECT_EQ(ret, E_BROKEN_IPC);
544     GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0200 End";
545 }
546 
547 /**
548  * @tc.name: DistributedFileDaemon_PrepareSession_0300
549  * @tc.desc: verify PrepareSession
550  * @tc.type: FUNC
551  * @tc.require: I7TDJK
552  */
553 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_PrepareSession_0300, TestSize.Level1)
554 {
555     GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0300 Start";
556     auto remoteReverseObj = sptr(new FileDfsListenerMock());
557     HmdfsInfo fileInfo;
558     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
559     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
560         .WillOnce(Return(true)).WillOnce(Return(true));
561     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
562         .WillOnce(Return(true));
563     EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
564     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
565     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
566     auto ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
567         remoteReverseObj->AsObject(), fileInfo);
568     EXPECT_EQ(ret, E_INVAL_ARG);
569 
570     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
571     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
572         .WillOnce(Return(true)).WillOnce(Return(true));
573     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
574         .WillOnce(Return(true));
575     EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
576     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
577     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
578     ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
579         remoteReverseObj->AsObject(), fileInfo);
580     EXPECT_EQ(ret, E_BROKEN_IPC);
581 
582     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
583     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
584         .WillOnce(Return(true)).WillOnce(Return(true));
585     EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
586         .WillOnce(Return(true));
587     EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
588     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
589     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
590     EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
591     ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
592         remoteReverseObj->AsObject(), fileInfo);
593     EXPECT_EQ(ret, E_INVAL_ARG);
594     GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0300 End";
595 }
596 
597 /**
598  * @tc.name: DistributedFileDaemon_RequestSendFile_0100
599  * @tc.desc: verify RequestSendFile.
600  * @tc.type: FUNC
601  * @tc.require: I7TDJK
602  */
603 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_RequestSendFile_0100, TestSize.Level1)
604 {
605     GTEST_LOG_(INFO) << "DistributedFileDaemon_RequestSendFile_0100 Start";
606     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
607     auto ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
608     EXPECT_EQ(ret, E_BROKEN_IPC);
609 
610     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
611     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
612     ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
613     EXPECT_EQ(ret, E_INVAL_ARG);
614 
615     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
616     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
617     ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
618     EXPECT_EQ(ret, E_INVAL_ARG);
619 
620     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
621     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
622         .WillOnce(Return(false));
623     ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
624     EXPECT_EQ(ret, E_INVAL_ARG);
625 
626     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
627     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
628         .WillOnce(Return(true)).WillOnce(Return(false));
629     ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
630     EXPECT_EQ(ret, E_INVAL_ARG);
631     GTEST_LOG_(INFO) << "DistributedFileDaemon_RequestSendFile_0100 End";
632 }
633 
634 /**
635  * @tc.name: DistributedFileDaemon_RequestSendFile_0200
636  * @tc.desc: verify RequestSendFile.
637  * @tc.type: FUNC
638  * @tc.require: I7TDJK
639  */
640 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_RequestSendFile_0200, TestSize.Level1)
641 {
642     GTEST_LOG_(INFO) << "DistributedFileDaemon_RequestSendFile_0200 Start";
643     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
644     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
645         .WillOnce(Return(true)).WillOnce(Return(true));
646 
647     auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
648     auto ret = testProxy->RequestSendFile("uri", "path", "deviceId", "test");
649     EXPECT_EQ(ret, E_BROKEN_IPC);
650 
651     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
652     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
653         .WillOnce(Return(true)).WillOnce(Return(true));
654     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
655     ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
656     EXPECT_EQ(ret, E_BROKEN_IPC);
657 
658     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
659     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
660         .WillOnce(Return(true)).WillOnce(Return(true));
661     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
662     EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
663     ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
664     EXPECT_EQ(ret, E_INVAL_ARG);
665     GTEST_LOG_(INFO) << "DistributedFileDaemon_RequestSendFile_0200 End";
666 }
667 
668 /**
669  * @tc.name: DistributedFileDaemon_GetRemoteCopyInfo_0100
670  * @tc.desc: verify GetRemoteCopyInfo.
671  * @tc.type: FUNC
672  * @tc.require: I7TDJK
673  */
674 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetRemoteCopyInfo_0100, TestSize.Level1)
675 {
676     GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0100 Start";
677     bool isFile = false;
678     bool isDir = false;
679     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
680     auto ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
681     EXPECT_EQ(ret, E_BROKEN_IPC);
682 
683     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
684     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
685     ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
686     EXPECT_EQ(ret, E_INVAL_ARG);
687 
688     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
689     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
690     auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
691     ret = testProxy->GetRemoteCopyInfo("test", isFile, isDir);
692     EXPECT_EQ(ret, E_BROKEN_IPC);
693     GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0100 End";
694 }
695 
696 /**
697  * @tc.name: DistributedFileDaemon_GetRemoteCopyInfo_0200
698  * @tc.desc: verify GetRemoteCopyInfo.
699  * @tc.type: FUNC
700  * @tc.require: I7TDJK
701  */
702 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetRemoteCopyInfo_0200, TestSize.Level1)
703 {
704     GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0200 Start";
705     bool isFile = false;
706     bool isDir = false;
707     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
708     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
709     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
710     auto ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
711     EXPECT_EQ(ret, E_BROKEN_IPC);
712 
713     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
714     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
715     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
716     EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(false));
717     ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
718     EXPECT_EQ(ret, E_INVAL_ARG);
719 
720     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
721     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
722     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
723     EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true)).WillOnce(Return(false));
724     ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
725     EXPECT_EQ(ret, E_INVAL_ARG);
726 
727     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
728     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
729     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
730     EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true)).WillOnce(Return(true));
731     EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
732     ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
733     EXPECT_EQ(ret, E_INVAL_ARG);
734     GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0200 End";
735 }
736 
737 /**
738  * @tc.name: DistributedFileDaemon_GetRemoteCopyInfo_0300
739  * @tc.desc: The execution of the GetRemoteCopyInfo success.
740  * @tc.type: FUNC
741  * @tc.require: I7TDJK
742  */
743 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetRemoteCopyInfo_0300, TestSize.Level1)
744 {
745     GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0300 Start";
746     bool isFile = false;
747     bool isDir = false;
748     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
749     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
750     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
751     EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true)).WillOnce(Return(true));
752     EXPECT_CALL(*messageParcelMock_, ReadInt32(_))
753         .WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)));
754     auto ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
755     EXPECT_EQ(ret, E_OK);
756     GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0300 End";
757 }
758 
759 /**
760  * @tc.name: DistributedFileDaemon_CancelCopyTask_0100
761  * @tc.desc: verify CancelCopyTask.
762  * @tc.type: FUNC
763  * @tc.require: I7TDJK
764  */
765 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CancelCopyTask_0100, TestSize.Level1)
766 {
767     GTEST_LOG_(INFO) << "DistributedFileDaemon_CancelCopyTask_0100 Start";
768     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
769     auto ret = proxy_->CancelCopyTask("test");
770     EXPECT_EQ(ret, E_BROKEN_IPC);
771 
772     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
773     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
774     ret = proxy_->CancelCopyTask("test");
775     EXPECT_EQ(ret, E_INVAL_ARG);
776 
777     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
778     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
779     auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
780     ret = testProxy->CancelCopyTask("test");
781     EXPECT_EQ(ret, E_BROKEN_IPC);
782 
783     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
784     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
785     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
786     ret = proxy_->CancelCopyTask("test");
787     EXPECT_EQ(ret, E_BROKEN_IPC);
788 
789     EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
790     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
791     EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
792     EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
793     ret = proxy_->CancelCopyTask("test");
794     EXPECT_EQ(ret, E_INVAL_ARG);
795     GTEST_LOG_(INFO) << "DistributedFileDaemon_CancelCopyTask_0100 End";
796 }
797 }