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