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 #include "copy/ipc_wrapper.h"
27
28 namespace {
29 bool g_writeBatchUrisTrue = true;
30 int32_t g_readBatchUris = OHOS::FileManagement::E_OK;
31 std::string g_context = "1";
32 }
33 namespace OHOS::Storage::DistributedFile {
WriteUriByRawData(MessageParcel & data,const std::vector<std::string> & uriVec)34 bool IpcWrapper::WriteUriByRawData(MessageParcel &data, const std::vector<std::string> &uriVec)
35 {
36 return true;
37 }
38
GetData(void * & buffer,size_t size,const void * data)39 bool IpcWrapper::GetData(void *&buffer, size_t size, const void *data)
40 {
41 return true;
42 }
43
ReadBatchUriByRawData(MessageParcel & data,std::vector<std::string> & uriVec)44 bool IpcWrapper::ReadBatchUriByRawData(MessageParcel &data, std::vector<std::string> &uriVec)
45 {
46 return true;
47 }
48
WriteBatchUris(MessageParcel & data,const std::vector<std::string> & uriVec)49 bool IpcWrapper::WriteBatchUris(MessageParcel &data, const std::vector<std::string> &uriVec)
50 {
51 return g_writeBatchUrisTrue;
52 }
53
ReadBatchUris(MessageParcel & data,std::vector<std::string> & uriVec)54 int32_t IpcWrapper::ReadBatchUris(MessageParcel &data, std::vector<std::string> &uriVec)
55 {
56 if (g_readBatchUris == FileManagement::E_OK) {
57 uriVec.emplace_back("key");
58 uriVec.emplace_back("uri");
59 uriVec.emplace_back(g_context);
60 }
61 return g_readBatchUris;
62 }
63 };
64
65 namespace OHOS::Storage::DistributedFile::Test {
66 using namespace OHOS::FileManagement;
67 using namespace testing;
68 using namespace testing::ext;
69 using namespace std;
70
71 class DistributedFileDaemonProxyTest : public testing::Test {
72 public:
73 static void SetUpTestCase(void);
74 static void TearDownTestCase(void);
75 void SetUp();
76 void TearDown();
77 public:
78 static inline shared_ptr<DistributedFileDaemonProxy> proxy_ = nullptr;
79 static inline sptr<DaemonServiceMock> mock_ = nullptr;
80 static inline shared_ptr<MessageParcelMock> messageParcelMock_ = nullptr;
81 };
82
SetUpTestCase(void)83 void DistributedFileDaemonProxyTest::SetUpTestCase(void)
84 {
85 GTEST_LOG_(INFO) << "SetUpTestCase";
86 mock_ = sptr(new DaemonServiceMock());
87 proxy_ = make_shared<DistributedFileDaemonProxy>(mock_);
88 messageParcelMock_ = make_shared<MessageParcelMock>();
89 MessageParcelMock::messageParcel = messageParcelMock_;
90 }
91
TearDownTestCase(void)92 void DistributedFileDaemonProxyTest::TearDownTestCase(void)
93 {
94 GTEST_LOG_(INFO) << "TearDownTestCase";
95 mock_ = nullptr;
96 proxy_ = nullptr;
97 messageParcelMock_ = nullptr;
98 MessageParcelMock::messageParcel = nullptr;
99 }
100
SetUp(void)101 void DistributedFileDaemonProxyTest::SetUp(void)
102 {
103 ASSERT_TRUE(mock_ != nullptr);
104 GTEST_LOG_(INFO) << "SetUp";
105 }
106
TearDown(void)107 void DistributedFileDaemonProxyTest::TearDown(void)
108 {
109 GTEST_LOG_(INFO) << "TearDown";
110 }
111
112 /**
113 * @tc.name: DistributedFileDaemon_OpenP2PConnection_0100
114 * @tc.desc: The execution of the OpenP2PConnection failed.
115 * @tc.type: FUNC
116 * @tc.require: I7TDJK
117 */
118 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_OpenP2PConnection_0100, TestSize.Level1)
119 {
120 GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0100 Start";
121 DistributedHardware::DmDeviceInfo deviceInfo;
122 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
123 auto ret = proxy_->OpenP2PConnection(deviceInfo);
124 EXPECT_EQ(ret, E_BROKEN_IPC);
125
126 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
127 EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(false));
128 ret = proxy_->OpenP2PConnection(deviceInfo);
129 EXPECT_EQ(ret, E_INVAL_ARG);
130
131 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
132 EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
133 .WillOnce(Return(false));
134 ret = proxy_->OpenP2PConnection(deviceInfo);
135 EXPECT_EQ(ret, E_INVAL_ARG);
136
137 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
138 EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
139 .WillOnce(Return(true)).WillOnce(Return(false));
140 ret = proxy_->OpenP2PConnection(deviceInfo);
141 EXPECT_EQ(ret, E_INVAL_ARG);
142
143 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
144 EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
145 .WillOnce(Return(true)).WillOnce(Return(true));
146 EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(false));
147 ret = proxy_->OpenP2PConnection(deviceInfo);
148 EXPECT_EQ(ret, E_INVAL_ARG);
149 GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnection_0100 End";
150 }
151
152 /**
153 * @tc.name: DistributedFileDaemon_CloseP2PConnection_0100
154 * @tc.desc: The execution of the CloseP2PConnection failed.
155 * @tc.type: FUNC
156 * @tc.require: I7TDJK
157 */
158 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CloseP2PConnection_0100, TestSize.Level1)
159 {
160 GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0100 Start";
161 DistributedHardware::DmDeviceInfo deviceInfo;
162 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
163 auto ret = proxy_->OpenP2PConnection(deviceInfo);
164 EXPECT_EQ(ret, E_BROKEN_IPC);
165
166 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
167 EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(false));
168 ret = proxy_->CloseP2PConnection(deviceInfo);
169 EXPECT_EQ(ret, E_INVAL_ARG);
170
171 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
172 EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
173 .WillOnce(Return(false));
174 ret = proxy_->CloseP2PConnection(deviceInfo);
175 EXPECT_EQ(ret, E_INVAL_ARG);
176
177 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
178 EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
179 .WillOnce(Return(true)).WillOnce(Return(false));
180 ret = proxy_->CloseP2PConnection(deviceInfo);
181 EXPECT_EQ(ret, E_INVAL_ARG);
182
183 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
184 EXPECT_CALL(*messageParcelMock_, WriteCString(_)).WillOnce(Return(true))
185 .WillOnce(Return(true)).WillOnce(Return(true));
186 EXPECT_CALL(*messageParcelMock_, WriteUint16(_)).WillOnce(Return(false));
187 ret = proxy_->CloseP2PConnection(deviceInfo);
188 EXPECT_EQ(ret, E_INVAL_ARG);
189 GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnection_0100 End";
190 }
191
192 /**
193 * @tc.name: DistributedFileDaemon_OpenP2PConnectionEx_0100
194 * @tc.desc: verify OpenP2PConnectionEx
195 * @tc.type: FUNC
196 * @tc.require: I7TDJK
197 */
198 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_OpenP2PConnectionEx_0100, TestSize.Level1)
199 {
200 GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnectionEx_0100 Start";
201 auto remoteReverseObj = sptr(new FileDfsListenerMock());
202 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
203 auto ret = proxy_->OpenP2PConnectionEx("test", remoteReverseObj);
204 EXPECT_EQ(ret, E_BROKEN_IPC);
205
206 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
207 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
208 ret = proxy_->OpenP2PConnectionEx("test", remoteReverseObj);
209 EXPECT_EQ(ret, E_INVAL_ARG);
210
211 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
212 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
213 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
214 .WillOnce(Return(false));
215 ret = proxy_->OpenP2PConnectionEx("test", remoteReverseObj);
216 EXPECT_EQ(ret, E_BROKEN_IPC);
217
218 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
219 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
220 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
221 .WillOnce(Return(true));
222 auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
223 ret = testProxy->OpenP2PConnectionEx("test", remoteReverseObj);
224 EXPECT_EQ(ret, E_BROKEN_IPC);
225 GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnectionEx_0100 End";
226 }
227
228 /**
229 * @tc.name: DistributedFileDaemon_OpenP2PConnectionEx_0200
230 * @tc.desc: verify OpenP2PConnectionEx
231 * @tc.type: FUNC
232 * @tc.require: I7TDJK
233 */
234 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_OpenP2PConnectionEx_0200, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnectionEx_0200 Start";
237 auto remoteReverseObj = sptr(new FileDfsListenerMock());
238 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
239 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
240 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
241 .WillOnce(Return(true));
242 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
243 auto ret = proxy_->OpenP2PConnectionEx("test", remoteReverseObj);
244 EXPECT_EQ(ret, E_BROKEN_IPC);
245
246 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
247 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
248 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
249 .WillOnce(Return(true));
250 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
251 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
252 ret = proxy_->OpenP2PConnectionEx("test", remoteReverseObj);
253 EXPECT_EQ(ret, E_INVAL_ARG);
254
255 sptr<FileDfsListenerMock> errPtr = nullptr;
256 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
257 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
258 ret = proxy_->OpenP2PConnectionEx("test", errPtr);
259 EXPECT_EQ(ret, E_BROKEN_IPC);
260 GTEST_LOG_(INFO) << "DistributedFileDaemon_OpenP2PConnectionEx_0200 End";
261 }
262
263 /**
264 * @tc.name: DistributedFileDaemon_CloseP2PConnectionEx_0100
265 * @tc.desc: verify CloseP2PConnectionEx
266 * @tc.type: FUNC
267 * @tc.require: I7TDJK
268 */
269 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CloseP2PConnectionEx_0100, TestSize.Level1)
270 {
271 GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnectionEx_0100 Start";
272 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
273 auto ret = proxy_->CloseP2PConnectionEx("test");
274 EXPECT_EQ(ret, E_BROKEN_IPC);
275
276 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
277 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
278 ret = proxy_->CloseP2PConnectionEx("test");
279 EXPECT_EQ(ret, E_INVAL_ARG);
280
281 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
282 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
283 auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
284 ret = testProxy->CloseP2PConnectionEx("test");
285 EXPECT_EQ(ret, E_BROKEN_IPC);
286 GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnectionEx_0100 End";
287 }
288
289 /**
290 * @tc.name: DistributedFileDaemon_CloseP2PConnectionEx_0200
291 * @tc.desc: verify CloseP2PConnectionEx
292 * @tc.type: FUNC
293 * @tc.require: I7TDJK
294 */
295 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CloseP2PConnectionEx_0200, TestSize.Level1)
296 {
297 GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnectionEx_0200 Start";
298 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
299 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
300 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
301 auto ret = proxy_->CloseP2PConnectionEx("test");
302 EXPECT_EQ(ret, E_BROKEN_IPC);
303
304 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
305 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
306 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
307 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
308 ret = proxy_->CloseP2PConnectionEx("test");
309 EXPECT_EQ(ret, E_INVAL_ARG);
310 GTEST_LOG_(INFO) << "DistributedFileDaemon_CloseP2PConnectionEx_0200 End";
311 }
312
313 /**
314 * @tc.name: DistributedFileDaemon_PrepareSession_0100
315 * @tc.desc: verify PrepareSession
316 * @tc.type: FUNC
317 * @tc.require: I7TDJK
318 */
319 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_PrepareSession_0100, TestSize.Level1)
320 {
321 GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0100 Start";
322 auto remoteReverseObj = sptr(new FileDfsListenerMock());
323 HmdfsInfo fileInfo;
324 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
325 auto ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
326 remoteReverseObj->AsObject(), fileInfo);
327 EXPECT_EQ(ret, E_BROKEN_IPC);
328
329 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
330 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
331 ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
332 remoteReverseObj->AsObject(), fileInfo);
333 EXPECT_EQ(ret, E_INVAL_ARG);
334
335 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
336 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
337 ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
338 remoteReverseObj->AsObject(), fileInfo);
339 EXPECT_EQ(ret, E_INVAL_ARG);
340
341 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
342 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
343 .WillOnce(Return(false));
344 ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
345 remoteReverseObj->AsObject(), fileInfo);
346 EXPECT_EQ(ret, E_INVAL_ARG);
347 GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0100 End";
348 }
349
350 /**
351 * @tc.name: DistributedFileDaemon_PrepareSession_0200
352 * @tc.desc: verify PrepareSession
353 * @tc.type: FUNC
354 * @tc.require: I7TDJK
355 */
356 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_PrepareSession_0200, TestSize.Level1)
357 {
358 GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0200 Start";
359 auto remoteReverseObj = sptr(new FileDfsListenerMock());
360 HmdfsInfo fileInfo;
361 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
362 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
363 .WillOnce(Return(true));
364 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
365 .WillOnce(Return(false));
366 auto ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
367 remoteReverseObj->AsObject(), fileInfo);
368 EXPECT_EQ(ret, E_INVAL_ARG);
369
370 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
371 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
372 .WillOnce(Return(true)).WillOnce(Return(false));
373 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
374 .WillOnce(Return(true));
375 ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
376 remoteReverseObj->AsObject(), fileInfo);
377 EXPECT_EQ(ret, E_INVAL_ARG);
378
379 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
380 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
381 .WillOnce(Return(true)).WillOnce(Return(true));
382 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
383 .WillOnce(Return(true));
384 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
385 ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
386 remoteReverseObj->AsObject(), fileInfo);
387 EXPECT_EQ(ret, E_INVAL_ARG);
388
389 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
390 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
391 .WillOnce(Return(true)).WillOnce(Return(true));
392 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
393 .WillOnce(Return(true));
394 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
395 auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
396 ret = testProxy->PrepareSession("srcUri", "dstUri", "deviceId",
397 remoteReverseObj->AsObject(), fileInfo);
398 EXPECT_EQ(ret, E_BROKEN_IPC);
399 GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0200 End";
400 }
401
402 /**
403 * @tc.name: DistributedFileDaemon_PrepareSession_0300
404 * @tc.desc: verify PrepareSession
405 * @tc.type: FUNC
406 * @tc.require: I7TDJK
407 */
408 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_PrepareSession_0300, TestSize.Level1)
409 {
410 GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0300 Start";
411 auto remoteReverseObj = sptr(new FileDfsListenerMock());
412 HmdfsInfo fileInfo;
413 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
414 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
415 .WillOnce(Return(true)).WillOnce(Return(true));
416 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
417 .WillOnce(Return(true));
418 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
419 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
420 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
421 auto ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
422 remoteReverseObj->AsObject(), fileInfo);
423 EXPECT_EQ(ret, E_INVAL_ARG);
424
425 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
426 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
427 .WillOnce(Return(true)).WillOnce(Return(true));
428 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
429 .WillOnce(Return(true));
430 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
431 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
432 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
433 ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
434 remoteReverseObj->AsObject(), fileInfo);
435 EXPECT_EQ(ret, E_BROKEN_IPC);
436
437 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
438 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
439 .WillOnce(Return(true)).WillOnce(Return(true));
440 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
441 .WillOnce(Return(true));
442 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true));
443 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
444 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
445 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
446 ret = proxy_->PrepareSession("srcUri", "dstUri", "deviceId",
447 remoteReverseObj->AsObject(), fileInfo);
448 EXPECT_EQ(ret, E_INVAL_ARG);
449 GTEST_LOG_(INFO) << "DistributedFileDaemon_PrepareSession_0300 End";
450 }
451
452 /**
453 * @tc.name: DistributedFileDaemon_RequestSendFile_0100
454 * @tc.desc: verify RequestSendFile.
455 * @tc.type: FUNC
456 * @tc.require: I7TDJK
457 */
458 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_RequestSendFile_0100, TestSize.Level1)
459 {
460 GTEST_LOG_(INFO) << "DistributedFileDaemon_RequestSendFile_0100 Start";
461 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
462 auto ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
463 EXPECT_EQ(ret, E_BROKEN_IPC);
464
465 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
466 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
467 ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
468 EXPECT_EQ(ret, E_INVAL_ARG);
469
470 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
471 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
472 ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
473 EXPECT_EQ(ret, E_INVAL_ARG);
474
475 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
476 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
477 .WillOnce(Return(false));
478 ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
479 EXPECT_EQ(ret, E_INVAL_ARG);
480
481 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
482 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
483 .WillOnce(Return(true)).WillOnce(Return(false));
484 ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
485 EXPECT_EQ(ret, E_INVAL_ARG);
486 GTEST_LOG_(INFO) << "DistributedFileDaemon_RequestSendFile_0100 End";
487 }
488
489 /**
490 * @tc.name: DistributedFileDaemon_RequestSendFile_0200
491 * @tc.desc: verify RequestSendFile.
492 * @tc.type: FUNC
493 * @tc.require: I7TDJK
494 */
495 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_RequestSendFile_0200, TestSize.Level1)
496 {
497 GTEST_LOG_(INFO) << "DistributedFileDaemon_RequestSendFile_0200 Start";
498 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
499 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
500 .WillOnce(Return(true)).WillOnce(Return(true));
501
502 auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
503 auto ret = testProxy->RequestSendFile("uri", "path", "deviceId", "test");
504 EXPECT_EQ(ret, E_BROKEN_IPC);
505
506 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
507 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
508 .WillOnce(Return(true)).WillOnce(Return(true));
509 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
510 ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
511 EXPECT_EQ(ret, E_BROKEN_IPC);
512
513 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
514 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true))
515 .WillOnce(Return(true)).WillOnce(Return(true));
516 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
517 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
518 ret = proxy_->RequestSendFile("uri", "path", "deviceId", "test");
519 EXPECT_EQ(ret, E_INVAL_ARG);
520 GTEST_LOG_(INFO) << "DistributedFileDaemon_RequestSendFile_0200 End";
521 }
522
523 /**
524 * @tc.name: DistributedFileDaemon_GetRemoteCopyInfo_0100
525 * @tc.desc: verify GetRemoteCopyInfo.
526 * @tc.type: FUNC
527 * @tc.require: I7TDJK
528 */
529 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetRemoteCopyInfo_0100, TestSize.Level1)
530 {
531 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0100 Start";
532 bool isFile = false;
533 bool isDir = false;
534 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
535 auto ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
536 EXPECT_EQ(ret, E_BROKEN_IPC);
537
538 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
539 EXPECT_CALL(*messageParcelMock_, WriteString(_)).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 auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
546 ret = testProxy->GetRemoteCopyInfo("test", isFile, isDir);
547 EXPECT_EQ(ret, E_BROKEN_IPC);
548 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0100 End";
549 }
550
551 /**
552 * @tc.name: DistributedFileDaemon_GetRemoteCopyInfo_0200
553 * @tc.desc: verify GetRemoteCopyInfo.
554 * @tc.type: FUNC
555 * @tc.require: I7TDJK
556 */
557 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetRemoteCopyInfo_0200, TestSize.Level1)
558 {
559 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0200 Start";
560 bool isFile = false;
561 bool isDir = false;
562 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
563 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
564 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
565 auto ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
566 EXPECT_EQ(ret, E_BROKEN_IPC);
567
568 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
569 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
570 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
571 EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(false));
572 ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
573 EXPECT_EQ(ret, E_INVAL_ARG);
574
575 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
576 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
577 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
578 EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true)).WillOnce(Return(false));
579 ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
580 EXPECT_EQ(ret, E_INVAL_ARG);
581
582 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
583 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
584 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
585 EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true)).WillOnce(Return(true));
586 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
587 ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
588 EXPECT_EQ(ret, E_INVAL_ARG);
589 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0200 End";
590 }
591
592 /**
593 * @tc.name: DistributedFileDaemon_GetRemoteCopyInfo_0300
594 * @tc.desc: The execution of the GetRemoteCopyInfo success.
595 * @tc.type: FUNC
596 * @tc.require: I7TDJK
597 */
598 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetRemoteCopyInfo_0300, TestSize.Level1)
599 {
600 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0300 Start";
601 bool isFile = false;
602 bool isDir = false;
603 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
604 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
605 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
606 EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true)).WillOnce(Return(true));
607 EXPECT_CALL(*messageParcelMock_, ReadInt32(_))
608 .WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)));
609 auto ret = proxy_->GetRemoteCopyInfo("test", isFile, isDir);
610 EXPECT_EQ(ret, E_OK);
611 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetRemoteCopyInfo_0300 End";
612 }
613
614 /**
615 * @tc.name: DistributedFileDaemon_CancelCopyTask_0100
616 * @tc.desc: verify CancelCopyTask.
617 * @tc.type: FUNC
618 * @tc.require: I7TDJK
619 */
620 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_CancelCopyTask_0100, TestSize.Level1)
621 {
622 GTEST_LOG_(INFO) << "DistributedFileDaemon_CancelCopyTask_0100 Start";
623 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
624 auto ret = proxy_->CancelCopyTask("test");
625 EXPECT_EQ(ret, E_BROKEN_IPC);
626
627 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
628 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
629 ret = proxy_->CancelCopyTask("test");
630 EXPECT_EQ(ret, E_INVAL_ARG);
631
632 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
633 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
634 auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
635 ret = testProxy->CancelCopyTask("test");
636 EXPECT_EQ(ret, E_BROKEN_IPC);
637
638 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
639 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
640 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
641 ret = proxy_->CancelCopyTask("test");
642 EXPECT_EQ(ret, E_BROKEN_IPC);
643
644 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
645 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
646 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
647 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_INVAL_ARG));
648 ret = proxy_->CancelCopyTask("test");
649 EXPECT_EQ(ret, E_INVAL_ARG);
650 GTEST_LOG_(INFO) << "DistributedFileDaemon_CancelCopyTask_0100 End";
651 }
652
653 /**
654 * @tc.name: DistributedFileDaemon_PushAsset_0100
655 * @tc.desc: verify PushAsset.
656 * @tc.type: FUNC
657 * @tc.require: I7TDJK
658 */
659 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_PushAsset_0100, TestSize.Level1)
660 {
661 GTEST_LOG_(INFO) << "DistributedFileDaemon_PushAsset_0100 Start";
662 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
663 sptr<AssetObj> assetObj(new (std::nothrow) AssetObj());
664 auto callbackMock = sptr(new IAssetSendCallbackMock());
665 auto ret = proxy_->PushAsset(100, assetObj, callbackMock);
666 EXPECT_EQ(ret, E_BROKEN_IPC);
667 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
668 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
669 ret = proxy_->PushAsset(100, assetObj, callbackMock);
670 EXPECT_EQ(ret, E_INVAL_ARG);
671
672 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
673 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
674 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(false));
675 ret = proxy_->PushAsset(100, assetObj, callbackMock);
676 EXPECT_EQ(ret, E_INVAL_ARG);
677
678 sptr<IAssetSendCallbackMock> errPtr = nullptr;
679 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
680 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
681 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
682 ret = proxy_->PushAsset(100, assetObj, errPtr);
683 EXPECT_EQ(ret, E_INVAL_ARG);
684
685 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
686 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
687 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
688 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
689 .WillOnce(Return(false));
690 ret = proxy_->PushAsset(100, assetObj, callbackMock);
691 EXPECT_EQ(ret, E_INVAL_ARG);
692
693 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
694 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
695 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
696 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
697 .WillOnce(Return(true));
698 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
699 ret = proxy_->PushAsset(100, assetObj, callbackMock);
700 EXPECT_EQ(ret, E_BROKEN_IPC);
701 GTEST_LOG_(INFO) << "DistributedFileDaemon_PushAsset_0100 End";
702 }
703
704 /**
705 * @tc.name: DistributedFileDaemon_PushAsset_0200
706 * @tc.desc: verify PushAsset.
707 * @tc.type: FUNC
708 * @tc.require: I7TDJK
709 */
710 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_PushAsset_0200, TestSize.Level1)
711 {
712 GTEST_LOG_(INFO) << "DistributedFileDaemon_PushAsset_0200 Start";
713 auto assetObj (new (std::nothrow) AssetObj());
714 auto callbackmock = sptr(new IAssetSendCallbackMock());
715
716 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
717 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
718 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
719 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
720 .WillOnce(Return(true));
721 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
722 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_OK));
723 auto ret = proxy_->PushAsset(100, assetObj, callbackmock);
724 EXPECT_EQ(ret, E_OK);
725 GTEST_LOG_(INFO) << "DistributedFileDaemon_PushAsset_0200 End";
726 }
727
728 /**
729 * @tc.name: DistributedFileDaemon_PushAsset_0300
730 * @tc.desc: verify PushAsset.
731 * @tc.type: FUNC
732 * @tc.require: I7TDJK
733 */
734 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_PushAsset_0300, TestSize.Level1)
735 {
736 GTEST_LOG_(INFO) << "DistributedFileDaemon_PushAsset_0300 Start";
737 auto assetObj (new (std::nothrow) AssetObj());
738 auto callbackmock = sptr(new IAssetSendCallbackMock());
739
740 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
741 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
742 EXPECT_CALL(*messageParcelMock_, WriteParcelable(_)).WillOnce(Return(true));
743 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
744 .WillOnce(Return(true));
745 auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
746 auto ret = testProxy->PushAsset(100, assetObj, callbackmock);
747 EXPECT_EQ(ret, E_BROKEN_IPC);
748 GTEST_LOG_(INFO) << "DistributedFileDaemon_PushAsset_0300 End";
749 }
750
751 /**
752 * @tc.name: DistributedFileDaemon_RegisterAssetCallback_0100
753 * @tc.desc: verify RegisterAssetCallback.
754 * @tc.type: FUNC
755 * @tc.require: I7TDJK
756 */
757 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_RegisterAssetCallback_0100, TestSize.Level1)
758 {
759 GTEST_LOG_(INFO) << "DistributedFileDaemon_RegisterAssetCallback_0100 Start";
760 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
761 auto recvCallback = sptr(new IAssetRecvCallbackMock());
762 auto ret = proxy_->RegisterAssetCallback(recvCallback);
763 EXPECT_EQ(ret, E_BROKEN_IPC);
764
765 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
766 sptr<IAssetRecvCallbackMock> errCallBack = nullptr;
767 ret = proxy_->RegisterAssetCallback(errCallBack);
768 EXPECT_EQ(ret, E_INVAL_ARG);
769
770 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
771 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
772 .WillOnce(Return(false));
773 ret = proxy_->RegisterAssetCallback(recvCallback);
774 EXPECT_EQ(ret, E_INVAL_ARG);
775
776 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
777 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
778 .WillOnce(Return(true));
779 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
780 ret = proxy_->RegisterAssetCallback(recvCallback);
781 EXPECT_EQ(ret, E_BROKEN_IPC);
782
783 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
784 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
785 .WillOnce(Return(true));
786 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
787 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_OK));
788 ret = proxy_->RegisterAssetCallback(recvCallback);
789 EXPECT_EQ(ret, E_OK);
790
791 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
792 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
793 .WillOnce(Return(true));
794 auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
795 ret = testProxy->RegisterAssetCallback(recvCallback);
796 EXPECT_EQ(ret, E_BROKEN_IPC);
797 GTEST_LOG_(INFO) << "DistributedFileDaemon_RegisterAssetCallback_0100 End";
798 }
799
800
801 /**
802 * @tc.name: DistributedFileDaemon_UnRegisterAssetCallback_0100
803 * @tc.desc: verify UnRegisterAssetCallback.
804 * @tc.type: FUNC
805 * @tc.require: I7TDJK
806 */
807 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_UnRegisterAssetCallback_0100, TestSize.Level1)
808 {
809 GTEST_LOG_(INFO) << "DistributedFileDaemon_UnRegisterAssetCallback_0100 Start";
810 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
811 auto recvCallback = sptr(new IAssetRecvCallbackMock());
812 auto ret = proxy_->UnRegisterAssetCallback(recvCallback);
813 EXPECT_EQ(ret, E_BROKEN_IPC);
814
815 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
816 sptr<IAssetRecvCallbackMock> errCallBack = nullptr;
817 ret = proxy_->UnRegisterAssetCallback(errCallBack);
818 EXPECT_EQ(ret, E_INVAL_ARG);
819
820 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
821 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
822 .WillOnce(Return(false));
823 ret = proxy_->UnRegisterAssetCallback(recvCallback);
824 EXPECT_EQ(ret, E_INVAL_ARG);
825
826 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
827 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
828 .WillOnce(Return(true));
829 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
830 ret = proxy_->UnRegisterAssetCallback(recvCallback);
831 EXPECT_EQ(ret, E_BROKEN_IPC);
832
833 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
834 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
835 .WillOnce(Return(true));
836 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
837 EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(E_OK));
838 ret = proxy_->UnRegisterAssetCallback(recvCallback);
839 EXPECT_EQ(ret, E_OK);
840
841 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
842 EXPECT_CALL(*messageParcelMock_, WriteRemoteObject(An<const sptr<IRemoteObject>&>()))
843 .WillOnce(Return(true));
844 auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
845 ret = testProxy->UnRegisterAssetCallback(recvCallback);
846 EXPECT_EQ(ret, E_BROKEN_IPC);
847 GTEST_LOG_(INFO) << "DistributedFileDaemon_UnRegisterAssetCallback_0100 End";
848 }
849
850 /**
851 * @tc.name: DistributedFileDaemon_GetDfsUrisDirFromLocal_0100
852 * @tc.desc: The execution of the GetDfsUrisDirFromLocal failed and success.
853 * @tc.type: FUNC
854 * @tc.require: I7TDJK
855 */
856 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetDfsUrisDirFromLocal_0100, TestSize.Level1)
857 {
858 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetDfsUrisDirFromLocal_0100 Start";
859 std::vector<std::string> uriList = {""};
860 int32_t userId = 101;
861 AppFileService::ModuleRemoteFileShare::HmdfsUriInfo uriInfo{"test", 2};
862 std::unordered_map<std::string, AppFileService::ModuleRemoteFileShare::HmdfsUriInfo> uriToDfsUriMaps;
863 uriToDfsUriMaps.insert({"test", uriInfo});
864 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
865 auto ret = proxy_->GetDfsUrisDirFromLocal(uriList, userId, uriToDfsUriMaps);
866 EXPECT_EQ(ret, E_BROKEN_IPC);
867
868 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
869 g_writeBatchUrisTrue = false;
870 ret = proxy_->GetDfsUrisDirFromLocal(uriList, userId, uriToDfsUriMaps);
871 EXPECT_EQ(ret, E_INVAL_ARG);
872
873 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
874 g_writeBatchUrisTrue = true;
875 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
876 ret = proxy_->GetDfsUrisDirFromLocal(uriList, userId, uriToDfsUriMaps);
877 EXPECT_EQ(ret, E_INVAL_ARG);
878
879 auto testProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
880 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
881 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
882 ret = testProxy->GetDfsUrisDirFromLocal(uriList, userId, uriToDfsUriMaps);
883 EXPECT_EQ(ret, E_BROKEN_IPC);
884
885 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
886 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
887 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
888 ret = proxy_->GetDfsUrisDirFromLocal(uriList, userId, uriToDfsUriMaps);
889 EXPECT_EQ(ret, E_BROKEN_IPC);
890
891 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
892 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
893 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
894 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
895 ret = proxy_->GetDfsUrisDirFromLocal(uriList, userId, uriToDfsUriMaps);
896 EXPECT_EQ(ret, E_BROKEN_IPC);
897
898 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
899 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
900 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
901 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_INVAL_ARG), Return(true)));
902 ret = proxy_->GetDfsUrisDirFromLocal(uriList, userId, uriToDfsUriMaps);
903 EXPECT_EQ(ret, E_INVAL_ARG);
904
905 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
906 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
907 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
908 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)));
909 ret = proxy_->GetDfsUrisDirFromLocal(uriList, userId, uriToDfsUriMaps);
910 EXPECT_EQ(ret, E_OK);
911 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetDfsUrisDirFromLocal_0100 End";
912 }
913
914 /**
915 * @tc.name: DistributedFileDaemon_GetDfsUrisDirFromLocal_0200
916 * @tc.desc: The execution of the GetDfsUrisDirFromLocal failed.
917 * @tc.type: FUNC
918 * @tc.require: I7TDJK
919 */
920 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetDfsUrisDirFromLocal_0200, TestSize.Level1)
921 {
922 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetDfsUrisDirFromLocal_0200 Start";
923 std::vector<std::string> uriList = {""};
924 int32_t userId = 101;
925 AppFileService::ModuleRemoteFileShare::HmdfsUriInfo uriInfo{"test", 2};
926 std::unordered_map<std::string, AppFileService::ModuleRemoteFileShare::HmdfsUriInfo> uriToDfsUriMaps;
927 uriToDfsUriMaps.insert({"test", uriInfo});
928
929 g_context = "aa";
930 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
931 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
932 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
933 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)));
934 auto ret = proxy_->GetDfsUrisDirFromLocal(uriList, userId, uriToDfsUriMaps);
935 EXPECT_EQ(ret, E_INVAL_ARG);
936
937 g_context = "1";
938 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
939 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)).WillOnce(Return(false));
940 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
941 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)));
942 g_readBatchUris = E_INVAL_ARG;
943 ret = proxy_->GetDfsUrisDirFromLocal(uriList, userId, uriToDfsUriMaps);
944 EXPECT_EQ(ret, E_IPC_READ_FAILED);
945 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetDfsUrisDirFromLocal_0200 End";
946 }
947
948 /**
949 * @tc.name: DistributedFileDaemon_GetDfsSwitchStatus
950 * @tc.desc: Verify GetDfsSwitchStatus function
951 * @tc.type: FUNC
952 * @tc.require: I7TDJK
953 */
954 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetDfsSwitchStatus, TestSize.Level1)
955 {
956 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetDfsSwitchStatus Start";
957 int32_t switchStatus = 0;
958 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
959 auto ret = proxy_->GetDfsSwitchStatus("networkId", switchStatus);
960 EXPECT_EQ(ret, E_BROKEN_IPC);
961
962 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
963 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
964 ret = proxy_->GetDfsSwitchStatus("networkId", switchStatus);
965 EXPECT_EQ(ret, E_BROKEN_IPC);
966
967 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
968 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
969 auto tmpProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
970 ret = tmpProxy->GetDfsSwitchStatus("networkId", switchStatus);
971 EXPECT_EQ(ret, E_BROKEN_IPC);
972
973 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
974 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
975 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
976 ret = proxy_->GetDfsSwitchStatus("networkId", switchStatus);
977 EXPECT_EQ(ret, E_BROKEN_IPC);
978
979 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
980 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
981 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
982 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
983 ret = proxy_->GetDfsSwitchStatus("networkId", switchStatus);
984 EXPECT_EQ(ret, E_BROKEN_IPC);
985
986 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
987 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
988 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
989 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_INVAL_ARG), Return(true)));
990 ret = proxy_->GetDfsSwitchStatus("networkId", switchStatus);
991 EXPECT_EQ(ret, E_INVAL_ARG);
992
993 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
994 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
995 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
996 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)))
997 .WillOnce(Return(false));
998 ret = proxy_->GetDfsSwitchStatus("networkId", switchStatus);
999 EXPECT_EQ(ret, E_BROKEN_IPC);
1000
1001 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1002 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
1003 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
1004 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)))
1005 .WillOnce(DoAll(SetArgReferee<0>(1), Return(true)));
1006 ret = proxy_->GetDfsSwitchStatus("networkId", switchStatus);
1007 EXPECT_EQ(ret, E_OK);
1008 EXPECT_EQ(switchStatus, 1);
1009 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetDfsSwitchStatus End";
1010 }
1011
1012 /**
1013 * @tc.name: DistributedFileDaemon_UpdateDfsSwitchStatus
1014 * @tc.desc: Verify UpdateDfsSwitchStatus function
1015 * @tc.type: FUNC
1016 * @tc.require: I7TDJK
1017 */
1018 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_UpdateDfsSwitchStatus, TestSize.Level1)
1019 {
1020 GTEST_LOG_(INFO) << "DistributedFileDaemon_UpdateDfsSwitchStatus Start";
1021 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1022 auto ret = proxy_->UpdateDfsSwitchStatus(1);
1023 EXPECT_EQ(ret, E_BROKEN_IPC);
1024
1025 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1026 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
1027 ret = proxy_->UpdateDfsSwitchStatus(1);
1028 EXPECT_EQ(ret, E_BROKEN_IPC);
1029
1030 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1031 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1032 auto tmpProxy = make_shared<DistributedFileDaemonProxy>(nullptr);
1033 ret = tmpProxy->UpdateDfsSwitchStatus(1);
1034 EXPECT_EQ(ret, E_BROKEN_IPC);
1035
1036 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1037 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1038 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
1039 ret = proxy_->UpdateDfsSwitchStatus(1);
1040 EXPECT_EQ(ret, E_BROKEN_IPC);
1041
1042 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1043 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1044 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
1045 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
1046 ret = proxy_->UpdateDfsSwitchStatus(1);
1047 EXPECT_EQ(ret, E_BROKEN_IPC);
1048
1049 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1050 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
1051 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
1052 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)));
1053 ret = proxy_->UpdateDfsSwitchStatus(1);
1054 EXPECT_EQ(ret, E_OK);
1055 GTEST_LOG_(INFO) << "DistributedFileDaemon_UpdateDfsSwitchStatus End";
1056 }
1057
1058 /**
1059 * @tc.name: DistributedFileDaemon_GetConnectedDeviceList
1060 * @tc.desc: Verify GetConnectedDeviceList function
1061 * @tc.type: FUNC
1062 * @tc.require: I7TDJK
1063 */
1064 HWTEST_F(DistributedFileDaemonProxyTest, DistributedFileDaemon_GetConnectedDeviceList, TestSize.Level1)
1065 {
1066 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetConnectedDeviceList Start";
1067 std::vector<DfsDeviceInfo> deviceList;
1068 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false));
1069 auto ret = proxy_->GetConnectedDeviceList(deviceList);
1070 EXPECT_EQ(ret, E_BROKEN_IPC);
1071
1072 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1073 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
1074 ret = proxy_->GetConnectedDeviceList(deviceList);
1075 EXPECT_EQ(ret, E_BROKEN_IPC);
1076
1077 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1078 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
1079 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
1080 ret = proxy_->GetConnectedDeviceList(deviceList);
1081 EXPECT_EQ(ret, E_BROKEN_IPC);
1082
1083 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1084 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
1085 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_INVAL_ARG), Return(true)));
1086 ret = proxy_->GetConnectedDeviceList(deviceList);
1087 EXPECT_EQ(ret, E_INVAL_ARG);
1088
1089 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1090 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
1091 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)))
1092 .WillOnce(Return(false));
1093 ret = proxy_->GetConnectedDeviceList(deviceList);
1094 EXPECT_EQ(ret, E_BROKEN_IPC);
1095
1096 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1097 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
1098 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)))
1099 .WillOnce(DoAll(SetArgReferee<0>(1), Return(true)));
1100 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
1101 ret = proxy_->GetConnectedDeviceList(deviceList);
1102 EXPECT_EQ(ret, E_BROKEN_IPC);
1103
1104 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1105 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
1106 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)))
1107 .WillOnce(DoAll(SetArgReferee<0>(1), Return(true)));
1108 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(false));
1109 ret = proxy_->GetConnectedDeviceList(deviceList);
1110 EXPECT_EQ(ret, E_BROKEN_IPC);
1111
1112 EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true));
1113 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(E_OK));
1114 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(E_OK), Return(true)))
1115 .WillOnce(DoAll(SetArgReferee<0>(1), Return(true)));
1116 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true));
1117 ret = proxy_->GetConnectedDeviceList(deviceList);
1118 EXPECT_EQ(ret, E_OK);
1119 GTEST_LOG_(INFO) << "DistributedFileDaemon_GetConnectedDeviceList End";
1120 }
1121 }
1122