1 /*
2 * Copyright (c) 2024-2025 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 "ipc/daemon_stub.h"
16
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 #include "ipc_skeleton.h"
21
22 #include "asset_recv_callback_mock.h"
23 #include "copy/ipc_wrapper.h"
24 #include "dfs_error.h"
25 #include "dfsu_access_token_helper.h"
26 #include "file_dfs_listener_mock.h"
27 #include "ipc/hmdfs_info.h"
28 #include "ipc/distributed_file_daemon_ipc_interface_code.h"
29 #include "i_daemon_mock.h"
30 #include "message_parcel_mock.h"
31 #include "utils_log.h"
32
33 namespace {
34 bool g_getCallingUidTrue = true;
35 bool g_checkUriPermissionTrue = true;
36 bool g_checkCallerPermissionTrue = true;
37 bool g_isLocalCalling = true;
38 constexpr pid_t DATA_UID = 3012;
39 constexpr pid_t DAEMON_UID = 1009;
40 static pid_t UID = DAEMON_UID;
41 bool g_writeBatchUrisTrue = true;
42 int32_t g_readBatchUris = true;
43 }
44
45 namespace OHOS::Storage::DistributedFile {
WriteUriByRawData(MessageParcel & data,const std::vector<std::string> & uriVec)46 bool IpcWrapper::WriteUriByRawData(MessageParcel &data, const std::vector<std::string> &uriVec)
47 {
48 return true;
49 }
50
GetData(void * & buffer,size_t size,const void * data)51 bool IpcWrapper::GetData(void *&buffer, size_t size, const void *data)
52 {
53 return true;
54 }
55
ReadBatchUriByRawData(MessageParcel & data,std::vector<std::string> & uriVec)56 bool IpcWrapper::ReadBatchUriByRawData(MessageParcel &data, std::vector<std::string> &uriVec)
57 {
58 return true;
59 }
60
WriteBatchUris(MessageParcel & data,const std::vector<std::string> & uriVec)61 bool IpcWrapper::WriteBatchUris(MessageParcel &data, const std::vector<std::string> &uriVec)
62 {
63 return g_writeBatchUrisTrue;
64 }
65
ReadBatchUris(MessageParcel & data,std::vector<std::string> & uriVec)66 int32_t IpcWrapper::ReadBatchUris(MessageParcel &data, std::vector<std::string> &uriVec)
67 {
68 if (g_readBatchUris == FileManagement::E_OK) {
69 uriVec.emplace_back("key");
70 uriVec.emplace_back("uri");
71 uriVec.emplace_back("1");
72 }
73 return g_readBatchUris;
74 }
75 };
76
77 namespace OHOS {
78 #ifdef CONFIG_IPC_SINGLE
79 using namespace IPC_SINGLE;
80 #endif
GetCallingUid()81 pid_t IPCSkeleton::GetCallingUid()
82 {
83 if (!g_getCallingUidTrue) {
84 return -1;
85 }
86
87 return UID;
88 }
89
IsLocalCalling()90 bool IPCSkeleton::IsLocalCalling()
91 {
92 return g_isLocalCalling;
93 }
94 }
95
96 namespace OHOS::FileManagement {
CheckUriPermission(const std::string & uriStr)97 bool DfsuAccessTokenHelper::CheckUriPermission(const std::string &uriStr)
98 {
99 if (g_checkUriPermissionTrue) {
100 return true;
101 }
102
103 return false;
104 }
105
CheckCallerPermission(const std::string & permissionName)106 bool DfsuAccessTokenHelper::CheckCallerPermission(const std::string &permissionName)
107 {
108 if (g_checkCallerPermissionTrue) {
109 return true;
110 }
111
112 return false;
113 }
114 }
115
116 namespace OHOS::Storage::DistributedFile::Test {
117 using namespace testing;
118 using namespace testing::ext;
119 using namespace std;
120 using namespace OHOS::FileManagement;
121
122 class MockDaemonSupStub : public DaemonStub {
123 public:
124 MOCK_METHOD1(OpenP2PConnection, int32_t(const DistributedHardware::DmDeviceInfo &deviceInfo));
125 MOCK_METHOD1(CloseP2PConnection, int32_t(const DistributedHardware::DmDeviceInfo &deviceInfo));
126 MOCK_METHOD2(OpenP2PConnectionEx, int32_t(const std::string &networkId, sptr<IFileDfsListener> remoteReverseObj));
127 MOCK_METHOD1(CloseP2PConnectionEx, int32_t(const std::string &networkId));
128 MOCK_METHOD4(RequestSendFile,
129 int32_t(const std::string &srcUri,
130 const std::string &dstPath,
131 const std::string &remoteDeviceId,
132 const std::string &sessionName));
133 MOCK_METHOD5(PrepareSession,
134 int32_t(const std::string &srcUri,
135 const std::string &dstUri,
136 const std::string &srcDeviceId,
137 const sptr<IRemoteObject> &listener,
138 HmdfsInfo &fileInfo));
139 MOCK_METHOD1(CancelCopyTask, int32_t(const std::string &sessionName));
140 MOCK_METHOD2(CancelCopyTask, int32_t(const std::string &srcUri, const std::string &dstUri));
141 MOCK_METHOD3(GetRemoteCopyInfo, int32_t(const std::string &srcUri, bool &isFile, bool &isDir));
142 MOCK_METHOD3(PushAsset, int32_t(int32_t userId,
143 const sptr<AssetObj> &assetObj,
144 const sptr<IAssetSendCallback> &sendCallback));
145 MOCK_METHOD1(RegisterAssetCallback, int32_t(const sptr<IAssetRecvCallback> &recvCallback));
146 MOCK_METHOD1(UnRegisterAssetCallback, int32_t(const sptr<IAssetRecvCallback> &recvCallback));
147 MOCK_METHOD3(GetDfsUrisDirFromLocal, int32_t(const std::vector<std::string> &uriList,
148 const int32_t userId,
149 std::unordered_map<std::string,
150 AppFileService::ModuleRemoteFileShare::HmdfsUriInfo>
151 &uriToDfsUriMaps));
152 MOCK_METHOD2(GetDfsSwitchStatus, int32_t(const std::string &networkId, int32_t &switchStatus));
153 MOCK_METHOD1(UpdateDfsSwitchStatus, int32_t(int32_t switchStatus));
154 MOCK_METHOD1(GetConnectedDeviceList, int32_t(std::vector<DfsDeviceInfo> &deviceList));
155 };
156
157 class DaemonStubSupPTest : public testing::Test {
158 public:
159 static void SetUpTestCase(void);
160 static void TearDownTestCase(void);
161 void SetUp();
162 void TearDown();
163 static inline std::shared_ptr<MockDaemonSupStub> daemonStub_;
164 static inline shared_ptr<MessageParcelMock> messageParcelMock_ = nullptr;
165 };
166
SetUpTestCase(void)167 void DaemonStubSupPTest::SetUpTestCase(void)
168 {
169 GTEST_LOG_(INFO) << "SetUpTestCase";
170 daemonStub_ = std::make_shared<MockDaemonSupStub>();
171 messageParcelMock_ = make_shared<MessageParcelMock>();
172 MessageParcelMock::messageParcel = messageParcelMock_;
173 }
174
TearDownTestCase(void)175 void DaemonStubSupPTest::TearDownTestCase(void)
176 {
177 GTEST_LOG_(INFO) << "TearDownTestCase";
178 daemonStub_ = nullptr;
179 MessageParcelMock::messageParcel = nullptr;
180 messageParcelMock_ = nullptr;
181 }
182
SetUp(void)183 void DaemonStubSupPTest::SetUp(void)
184 {
185 GTEST_LOG_(INFO) << "SetUp";
186 }
187
TearDown(void)188 void DaemonStubSupPTest::TearDown(void)
189 {
190 GTEST_LOG_(INFO) << "TearDown";
191 }
192
193 /**
194 * @tc.name: DaemonStubSupOnRemoteRequestTest001
195 * @tc.desc: Verify the OnRemoteRequest function
196 * @tc.type: FUNC
197 * @tc.require: I7M6L1
198 */
199 HWTEST_F(DaemonStubSupPTest, DaemonStubSupOnRemoteRequestTest001, TestSize.Level0)
200 {
201 GTEST_LOG_(INFO) << "DaemonStubSupOnRemoteRequestTest001 Start";
202 uint32_t code = static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_OPEN_P2P_CONNECTION);
203 MessageParcel data;
204 MessageParcel reply;
205 MessageOption option;
206 EXPECT_CALL(*messageParcelMock_, ReadInterfaceToken()).WillOnce(Return(u"test"));
207 auto ret = daemonStub_->OnRemoteRequest(code, data, reply, option);
208 EXPECT_EQ(ret, MockDaemonSupStub::DFS_DAEMON_DESCRIPTOR_IS_EMPTY);
209
210 EXPECT_CALL(*messageParcelMock_, ReadInterfaceToken()).WillOnce(Return(IDaemon::GetDescriptor()));
211 uint32_t errCode = 65535;
212 g_isLocalCalling = false;
213 ret = daemonStub_->OnRemoteRequest(errCode, data, reply, option);
214 EXPECT_EQ(ret, E_ALLOW_LOCAL_CALL_ONLY);
215
216 EXPECT_CALL(*messageParcelMock_, ReadInterfaceToken()).WillOnce(Return(IDaemon::GetDescriptor()));
217 code = static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_REQUEST_SEND_FILE);
218 ret = daemonStub_->OnRemoteRequest(code, data, reply, option);
219 EXPECT_EQ(ret, E_IPC_READ_FAILED);
220
221 EXPECT_CALL(*messageParcelMock_, ReadInterfaceToken()).WillOnce(Return(IDaemon::GetDescriptor()));
222 code = static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_GET_REMOTE_COPY_INFO);
223 ret = daemonStub_->OnRemoteRequest(code, data, reply, option);
224 EXPECT_EQ(ret, E_IPC_READ_FAILED);
225
226 g_isLocalCalling = true;
227 daemonStub_->opToInterfaceMap_.insert(make_pair(errCode, nullptr));
228 EXPECT_CALL(*messageParcelMock_, ReadInterfaceToken()).WillOnce(Return(IDaemon::GetDescriptor()));
229 ret = daemonStub_->OnRemoteRequest(errCode, data, reply, option);
230 EXPECT_EQ(ret, 305);
231 daemonStub_->opToInterfaceMap_.erase(errCode);
232 GTEST_LOG_(INFO) << "DaemonStubSupOnRemoteRequestTest001 End";
233 }
234
235 /**
236 * @tc.name: DaemonStubSupHandleOpenP2PConnectionExTest001
237 * @tc.desc: Verify the DaemonStubSupHandleOpenP2PConnectionExTest001 function
238 * @tc.type: FUNC
239 * @tc.require: I7M6L1
240 */
241 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleOpenP2PConnectionExTest001, TestSize.Level0)
242 {
243 GTEST_LOG_(INFO) << "DaemonStubSupHandleOpenP2PConnectionExTest001 Start";
244 MessageParcel data;
245 MessageParcel reply;
246 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
247 auto ret = daemonStub_->HandleOpenP2PConnectionEx(data, reply);
248 EXPECT_EQ(ret, E_IPC_READ_FAILED);
249
250 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
251 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(nullptr));
252 ret = daemonStub_->HandleOpenP2PConnectionEx(data, reply);
253 EXPECT_EQ(ret, E_IPC_READ_FAILED);
254
255 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
256 sptr<IRemoteObject> listenerPtr = sptr(new FileDfsListenerMock());
257 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listenerPtr));
258 EXPECT_CALL(*daemonStub_, OpenP2PConnectionEx(_, _)).WillOnce(Return(E_OK));
259 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
260 ret = daemonStub_->HandleOpenP2PConnectionEx(data, reply);
261 EXPECT_EQ(ret, E_OK);
262 GTEST_LOG_(INFO) << "DaemonStubSupHandleOpenP2PConnectionExTest001 End";
263 }
264
265 /**
266 * @tc.name: DaemonStubSupHandleCloseP2PConnectionExTest001
267 * @tc.desc: Verify the HandleCloseP2PConnectionEx function
268 * @tc.type: FUNC
269 * @tc.require: I7M6L1
270 */
271 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleCloseP2PConnectionExTest001, TestSize.Level0)
272 {
273 GTEST_LOG_(INFO) << "DaemonStubSupHandleCancelCopyTaskTest001 Start";
274 MessageParcel data;
275 MessageParcel reply;
276 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
277 auto ret = daemonStub_->HandleCloseP2PConnectionEx(data, reply);
278 EXPECT_EQ(ret, E_IPC_READ_FAILED);
279
280 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
281 EXPECT_CALL(*daemonStub_, CloseP2PConnectionEx(_)).WillOnce(Return(E_OK));
282 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
283 ret = daemonStub_->HandleCloseP2PConnectionEx(data, reply);
284 EXPECT_EQ(ret, E_OK);
285 GTEST_LOG_(INFO) << "DaemonStubSupHandleCloseP2PConnectionExTest001 End";
286 }
287
288 /**
289 * @tc.name: DaemonStubSupHandlePrepareSessionTest001
290 * @tc.desc: Verify the HandlePrepareSession function
291 * @tc.type: FUNC
292 * @tc.require: I7M6L1
293 */
294 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandlePrepareSessionTest001, TestSize.Level0)
295 {
296 GTEST_LOG_(INFO) << "DaemonStubSupHandlePrepareSessionTest001 Start";
297 MessageParcel data;
298 MessageParcel reply;
299
300 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
301 auto ret = daemonStub_->HandlePrepareSession(data, reply);
302 EXPECT_EQ(ret, E_IPC_READ_FAILED);
303
304 g_checkUriPermissionTrue = false;
305 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
306 ret = daemonStub_->HandlePrepareSession(data, reply);
307 EXPECT_EQ(ret, E_PERMISSION_DENIED);
308
309 g_checkUriPermissionTrue = true;
310 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(false));
311 ret = daemonStub_->HandlePrepareSession(data, reply);
312 EXPECT_EQ(ret, E_IPC_READ_FAILED);
313
314 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
315 .WillOnce(Return(false));
316 ret = daemonStub_->HandlePrepareSession(data, reply);
317 EXPECT_EQ(ret, E_IPC_READ_FAILED);
318
319 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
320 .WillOnce(Return(true));
321 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(nullptr));
322 ret = daemonStub_->HandlePrepareSession(data, reply);
323 EXPECT_EQ(ret, E_IPC_READ_FAILED);
324
325 sptr<IRemoteObject> listenerPtr = sptr(new DaemonServiceMock());
326 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
327 .WillOnce(Return(true)).WillOnce(Return(false));
328 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listenerPtr));
329 ret = daemonStub_->HandlePrepareSession(data, reply);
330 EXPECT_EQ(ret, E_IPC_READ_FAILED);
331 GTEST_LOG_(INFO) << "DaemonStubSupHandlePrepareSessionTest001 End";
332 }
333
334 /**
335 * @tc.name: DaemonStubSupHandlePrepareSessionTest002
336 * @tc.desc: Verify the HandlePrepareSession function
337 * @tc.type: FUNC
338 * @tc.require: I7M6L1
339 */
340 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandlePrepareSessionTest002, TestSize.Level0)
341 {
342 GTEST_LOG_(INFO) << "DaemonStubSupHandlePrepareSessionTest002 Start";
343 MessageParcel data;
344 MessageParcel reply;
345 g_checkUriPermissionTrue = true;
346 sptr<IRemoteObject> listenerPtr = sptr(new DaemonServiceMock());
347 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
348 .WillOnce(Return(true)).WillOnce(Return(true));
349 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listenerPtr));
350 EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(false));
351 auto ret = daemonStub_->HandlePrepareSession(data, reply);
352 EXPECT_EQ(ret, E_IPC_READ_FAILED);
353
354 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
355 .WillOnce(Return(true)).WillOnce(Return(true));
356 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listenerPtr));
357 EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true));
358 EXPECT_CALL(*daemonStub_, PrepareSession(_, _, _, _, _)).WillOnce(Return(E_INVAL_ARG));
359 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
360 ret = daemonStub_->HandlePrepareSession(data, reply);
361 EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
362
363 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
364 .WillOnce(Return(true)).WillOnce(Return(true));
365 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listenerPtr));
366 EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true));
367 EXPECT_CALL(*daemonStub_, PrepareSession(_, _, _, _, _)).WillOnce(Return(E_INVAL_ARG));
368 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
369 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
370 ret = daemonStub_->HandlePrepareSession(data, reply);
371 EXPECT_EQ(ret, E_INVAL_ARG);
372 GTEST_LOG_(INFO) << "DaemonStubSupHandlePrepareSessionTest002 End";
373 }
374
375 /**
376 * @tc.name: DaemonStubSupHandleRequestSendFileTest001
377 * @tc.desc: Verify the HandleRequestSendFile function
378 * @tc.type: FUNC
379 * @tc.require: I7M6L1
380 */
381 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleRequestSendFileTest001, TestSize.Level0)
382 {
383 GTEST_LOG_(INFO) << "DaemonStubSupHandleRequestSendFileTest001 Start";
384 UID = DAEMON_UID;
385 MessageParcel data;
386 MessageParcel reply;
387
388 g_getCallingUidTrue = true;
389 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
390 auto ret = daemonStub_->HandleRequestSendFile(data, reply);
391 EXPECT_EQ(ret, E_IPC_READ_FAILED);
392
393 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(false));
394 ret = daemonStub_->HandleRequestSendFile(data, reply);
395 EXPECT_EQ(ret, E_IPC_READ_FAILED);
396
397 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
398 .WillOnce(Return(false));
399 ret = daemonStub_->HandleRequestSendFile(data, reply);
400 EXPECT_EQ(ret, E_IPC_READ_FAILED);
401
402 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
403 .WillOnce(Return(true)).WillOnce(Return(false));
404 ret = daemonStub_->HandleRequestSendFile(data, reply);
405 EXPECT_EQ(ret, E_IPC_READ_FAILED);
406
407 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
408 .WillOnce(Return(true)).WillOnce(Return(true));
409 EXPECT_CALL(*daemonStub_, RequestSendFile(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
410 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
411 ret = daemonStub_->HandleRequestSendFile(data, reply);
412 EXPECT_EQ(ret, E_INVAL_ARG);
413 GTEST_LOG_(INFO) << "DaemonStubSupHandleRequestSendFileTest001 End";
414 }
415
416 /**
417 * @tc.name: DaemonStubSupHandleGetRemoteCopyInfoTest001
418 * @tc.desc: Verify the HandleGetRemoteCopyInfo function
419 * @tc.type: FUNC
420 * @tc.require: I7M6L1
421 */
422 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleGetRemoteCopyInfoTest001, TestSize.Level0)
423 {
424 GTEST_LOG_(INFO) << "DaemonStubSupHandleGetRemoteCopyInfoTest001 Start";
425 UID = DAEMON_UID;
426 MessageParcel data;
427 MessageParcel reply;
428
429 g_getCallingUidTrue = true;
430 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
431 auto ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
432 EXPECT_EQ(ret, E_IPC_READ_FAILED);
433
434 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
435 EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_INVAL_ARG));
436 ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
437 EXPECT_EQ(ret, E_IPC_READ_FAILED);
438
439 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
440 EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_OK));
441 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
442 ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
443 EXPECT_EQ(ret, E_IPC_READ_FAILED);
444
445 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
446 EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_OK));
447 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)).WillOnce(Return(false));
448 ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
449 EXPECT_EQ(ret, E_IPC_READ_FAILED);
450
451 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
452 EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_OK));
453 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)).WillOnce(Return(true));
454 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
455 ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
456 EXPECT_EQ(ret, E_IPC_READ_FAILED);
457
458 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
459 EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_OK));
460 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)).WillOnce(Return(true));
461 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
462 ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
463 EXPECT_EQ(ret, E_OK);
464 GTEST_LOG_(INFO) << "DaemonStubSupHandleGetRemoteCopyInfoTest001 End";
465 }
466
467 /**
468 * @tc.name: DaemonStubSupHandleGetRemoteCopyInfoTest002
469 * @tc.desc: Verify the HandleGetRemoteCopyInfo function
470 * @tc.type: FUNC
471 * @tc.require: I7M6L1
472 */
473 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleGetRemoteCopyInfoTest002, TestSize.Level0)
474 {
475 GTEST_LOG_(INFO) << "DaemonStubSupHandleGetRemoteCopyInfoTest002 Start";
476 UID = DAEMON_UID;
477 MessageParcel data;
478 MessageParcel reply;
479
480 g_getCallingUidTrue = true;
481 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
482 EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_OK));
483 EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)).WillOnce(Return(true));
484 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
485 auto ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
486 EXPECT_EQ(ret, E_OK);
487 GTEST_LOG_(INFO) << "DaemonStubSupHandleGetRemoteCopyInfoTest002 End";
488 }
489
490 /**
491 * @tc.name: DaemonStubSupHandleCancelCopyTaskTest001
492 * @tc.desc: Verify the HandleCancelCopyTask function
493 * @tc.type: FUNC
494 * @tc.require: I7M6L1
495 */
496 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleCancelCopyTaskTest001, TestSize.Level0)
497 {
498 GTEST_LOG_(INFO) << "DaemonStubSupHandleCancelCopyTaskTest001 Start";
499 MessageParcel data;
500 MessageParcel reply;
501 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
502 auto ret = daemonStub_->HandleCancelCopyTask(data, reply);
503 EXPECT_EQ(ret, E_IPC_READ_FAILED);
504
505 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
506 EXPECT_CALL(*daemonStub_, CancelCopyTask(_)).WillOnce(Return(E_OK));
507 ret = daemonStub_->HandleCancelCopyTask(data, reply);
508 EXPECT_EQ(ret, E_OK);
509 GTEST_LOG_(INFO) << "DaemonStubSupHandleCancelCopyTaskTest001 End";
510 }
511
512 /**
513 * @tc.name: DaemonStubSupHandleRegisterRecvCallback001
514 * @tc.desc: Verify the HandleRegisterRecvCallback function
515 * @tc.type: FUNC
516 * @tc.require: I7M6L1
517 */
518 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleRegisterRecvCallback001, TestSize.Level0)
519 {
520 GTEST_LOG_(INFO) << "DaemonStubSupHandleRegisterRecvCallback001 Start";
521 UID = DATA_UID;
522 MessageParcel data;
523 MessageParcel reply;
524 g_checkCallerPermissionTrue = false;
525 auto ret = daemonStub_->HandleRegisterRecvCallback(data, reply);
526 EXPECT_EQ(ret, E_PERMISSION_DENIED);
527
528 g_checkCallerPermissionTrue = true;
529 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(nullptr));
530 ret = daemonStub_->HandleRegisterRecvCallback(data, reply);
531 EXPECT_EQ(ret, E_IPC_READ_FAILED);
532
533 auto recvCallback = sptr(new IAssetRecvCallbackMock());
534 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(recvCallback));
535 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
536 EXPECT_CALL(*daemonStub_, RegisterAssetCallback(_)).WillOnce(Return(E_OK));
537 ret = daemonStub_->HandleRegisterRecvCallback(data, reply);
538 EXPECT_EQ(ret, E_IPC_READ_FAILED);
539
540 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(recvCallback));
541 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
542 EXPECT_CALL(*daemonStub_, RegisterAssetCallback(_)).WillOnce(Return(E_OK));
543 ret = daemonStub_->HandleRegisterRecvCallback(data, reply);
544 EXPECT_EQ(ret, E_OK);
545 GTEST_LOG_(INFO) << "DaemonStubSupHandleRegisterRecvCallback001 End";
546 }
547
548 /**
549 * @tc.name: DaemonStubSupHandleUnRegisterRecvCallback001
550 * @tc.desc: Verify the HandleUnRegisterRecvCallback function
551 * @tc.type: FUNC
552 * @tc.require: I7M6L1
553 */
554 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleUnRegisterRecvCallback001, TestSize.Level0)
555 {
556 GTEST_LOG_(INFO) << "DaemonStubSupHandleUnRegisterRecvCallback001 Start";
557 UID = DATA_UID;
558 MessageParcel data;
559 MessageParcel reply;
560 g_checkCallerPermissionTrue = false;
561 auto ret = daemonStub_->HandleUnRegisterRecvCallback(data, reply);
562 EXPECT_EQ(ret, E_PERMISSION_DENIED);
563
564 g_checkCallerPermissionTrue = true;
565 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(nullptr));
566 ret = daemonStub_->HandleUnRegisterRecvCallback(data, reply);
567 EXPECT_EQ(ret, E_IPC_READ_FAILED);
568
569 auto recvCallback = sptr(new IAssetRecvCallbackMock());
570 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(recvCallback));
571 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
572 EXPECT_CALL(*daemonStub_, UnRegisterAssetCallback(_)).WillOnce(Return(E_OK));
573 ret = daemonStub_->HandleUnRegisterRecvCallback(data, reply);
574 EXPECT_EQ(ret, E_IPC_READ_FAILED);
575
576 EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(recvCallback));
577 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
578 EXPECT_CALL(*daemonStub_, UnRegisterAssetCallback(_)).WillOnce(Return(E_OK));
579 ret = daemonStub_->HandleUnRegisterRecvCallback(data, reply);
580 EXPECT_EQ(ret, E_OK);
581 GTEST_LOG_(INFO) << "DaemonStubSupHandleUnRegisterRecvCallback001 End";
582 }
583
584 /**
585 * @tc.name: DaemonStubSupHandleGetDfsUrisDirFromLocalTest
586 * @tc.desc: Verify URI list read failure in HandleGetDfsUrisDirFromLocal
587 * @tc.type: FUNC
588 * @tc.require: I7M6L1
589 */
590 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleGetDfsUrisDirFromLocalTest, TestSize.Level0)
591 {
592 GTEST_LOG_(INFO) << "DaemonStubSupHandleGetDfsUrisDirFromLocalTest Start";
593 MessageParcel data;
594 MessageParcel reply;
595 g_readBatchUris = E_IPC_READ_FAILED;
596 auto ret = daemonStub_->HandleGetDfsUrisDirFromLocal(data, reply);
597 EXPECT_EQ(ret, E_IPC_READ_FAILED);
598
599 g_readBatchUris = E_OK;
600 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
601 ret = daemonStub_->HandleGetDfsUrisDirFromLocal(data, reply);
602 EXPECT_EQ(ret, E_IPC_READ_FAILED);
603
604 std::unordered_map<std::string, AppFileService::ModuleRemoteFileShare::HmdfsUriInfo> uriToDfsUriMaps;
605 uriToDfsUriMaps.emplace("key", AppFileService::ModuleRemoteFileShare::HmdfsUriInfo{"uri", 1}); // 1: test size
606 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(true));
607 EXPECT_CALL(*daemonStub_, GetDfsUrisDirFromLocal(_, _, _))
608 .WillOnce(DoAll(SetArgReferee<2>(uriToDfsUriMaps), Return(E_OK)));
609 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
610 ret = daemonStub_->HandleGetDfsUrisDirFromLocal(data, reply);
611 EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
612
613 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(true));
614 EXPECT_CALL(*daemonStub_, GetDfsUrisDirFromLocal(_, _, _))
615 .WillOnce(DoAll(SetArgReferee<2>(uriToDfsUriMaps), Return(E_IPC_WRITE_FAILED)));
616 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
617 ret = daemonStub_->HandleGetDfsUrisDirFromLocal(data, reply);
618 EXPECT_EQ(ret, E_OK);
619
620 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(true));
621 EXPECT_CALL(*daemonStub_, GetDfsUrisDirFromLocal(_, _, _))
622 .WillOnce(DoAll(SetArgReferee<2>(uriToDfsUriMaps), Return(E_OK)));
623 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
624 g_writeBatchUrisTrue = false;
625 ret = daemonStub_->HandleGetDfsUrisDirFromLocal(data, reply);
626 EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
627
628 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(true));
629 EXPECT_CALL(*daemonStub_, GetDfsUrisDirFromLocal(_, _, _))
630 .WillOnce(DoAll(SetArgReferee<2>(uriToDfsUriMaps), Return(E_OK)));
631 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
632 g_writeBatchUrisTrue = true;
633 ret = daemonStub_->HandleGetDfsUrisDirFromLocal(data, reply);
634 EXPECT_EQ(ret, E_OK);
635 GTEST_LOG_(INFO) << "DaemonStubSupHandleGetDfsUrisDirFromLocalTest End";
636 }
637
638 /**
639 * @tc.name: DaemonStubSupHandleGetDfsSwitchStatus
640 * @tc.desc: Verify the HandleGetDfsSwitchStatus function
641 * @tc.type: FUNC
642 * @tc.require: I7M6L1
643 */
644 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleGetDfsSwitchStatus, TestSize.Level0)
645 {
646 GTEST_LOG_(INFO) << "DaemonStubSupHandleGetDfsSwitchStatus Start";
647 MessageParcel data;
648 MessageParcel reply;
649 g_checkCallerPermissionTrue = false;
650 auto ret = daemonStub_->HandleGetDfsSwitchStatus(data, reply);
651 EXPECT_EQ(ret, E_PERMISSION_DENIED);
652
653 g_checkCallerPermissionTrue = true;
654 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
655 ret = daemonStub_->HandleGetDfsSwitchStatus(data, reply);
656 EXPECT_EQ(ret, E_IPC_READ_FAILED);
657
658 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
659 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
660 EXPECT_CALL(*daemonStub_, GetDfsSwitchStatus(_, _)).WillOnce(Return(E_OK));
661 ret = daemonStub_->HandleGetDfsSwitchStatus(data, reply);
662 EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
663
664 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
665 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
666 EXPECT_CALL(*daemonStub_, GetDfsSwitchStatus(_, _)).WillOnce(Return(E_INVAL_ARG));
667 ret = daemonStub_->HandleGetDfsSwitchStatus(data, reply);
668 EXPECT_EQ(ret, E_OK);
669
670 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return("networkId"));
671 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true))
672 .WillOnce(Return(false));
673 EXPECT_CALL(*daemonStub_, GetDfsSwitchStatus(_, _)).WillOnce(Return(E_OK));
674 ret = daemonStub_->HandleGetDfsSwitchStatus(data, reply);
675 EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
676
677 EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return("networkId"));
678 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true))
679 .WillOnce(Return(true));
680 EXPECT_CALL(*daemonStub_, GetDfsSwitchStatus(_, _)).WillOnce(Return(E_OK));
681 ret = daemonStub_->HandleGetDfsSwitchStatus(data, reply);
682 EXPECT_EQ(ret, E_OK);
683 GTEST_LOG_(INFO) << "DaemonStubSupHandleGetDfsSwitchStatus End";
684 }
685
686 /**
687 * @tc.name: DaemonStubSupHandleUpdateDfsSwitchStatus
688 * @tc.desc: Verify the HandleUpdateDfsSwitchStatus function
689 * @tc.type: FUNC
690 * @tc.require: I7M6L1
691 */
692 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleUpdateDfsSwitchStatus, TestSize.Level0)
693 {
694 GTEST_LOG_(INFO) << "DaemonStubSupHandleUpdateDfsSwitchStatus Start";
695 MessageParcel data;
696 MessageParcel reply;
697 g_checkCallerPermissionTrue = false;
698 auto ret = daemonStub_->HandleUpdateDfsSwitchStatus(data, reply);
699 EXPECT_EQ(ret, E_PERMISSION_DENIED);
700
701 g_checkCallerPermissionTrue = true;
702 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false));
703 ret = daemonStub_->HandleUpdateDfsSwitchStatus(data, reply);
704 EXPECT_EQ(ret, E_IPC_READ_FAILED);
705
706 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(true));
707 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
708 EXPECT_CALL(*daemonStub_, UpdateDfsSwitchStatus(_)).WillOnce(Return(E_OK));
709 ret = daemonStub_->HandleUpdateDfsSwitchStatus(data, reply);
710 EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
711
712 EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(true));
713 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
714 EXPECT_CALL(*daemonStub_, UpdateDfsSwitchStatus(_)).WillOnce(Return(E_OK));
715 ret = daemonStub_->HandleUpdateDfsSwitchStatus(data, reply);
716 EXPECT_EQ(ret, E_OK);
717 GTEST_LOG_(INFO) << "DaemonStubSupHandleUpdateDfsSwitchStatus End";
718 }
719
720 /**
721 * @tc.name: DaemonStubSupHandleGetConnectedDeviceList
722 * @tc.desc: Verify the HandleGetConnectedDeviceList function
723 * @tc.type: FUNC
724 * @tc.require: I7M6L1
725 */
726 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleGetConnectedDeviceList, TestSize.Level0)
727 {
728 GTEST_LOG_(INFO) << "DaemonStubSupHandleGetConnectedDeviceList Start";
729 MessageParcel data;
730 MessageParcel reply;
731 g_checkCallerPermissionTrue = false;
732 auto ret = daemonStub_->HandleGetConnectedDeviceList(data, reply);
733 EXPECT_EQ(ret, E_PERMISSION_DENIED);
734
735 g_checkCallerPermissionTrue = true;
736 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
737 EXPECT_CALL(*daemonStub_, GetConnectedDeviceList(_)).WillOnce(Return(E_OK));
738 ret = daemonStub_->HandleGetConnectedDeviceList(data, reply);
739 EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
740
741 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
742 EXPECT_CALL(*daemonStub_, GetConnectedDeviceList(_)).WillOnce(Return(E_INVAL_ARG));
743 ret = daemonStub_->HandleGetConnectedDeviceList(data, reply);
744 EXPECT_EQ(ret, E_OK);
745
746 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true))
747 .WillOnce(Return(false));
748 EXPECT_CALL(*daemonStub_, GetConnectedDeviceList(_)).WillOnce(Return(E_OK));
749 ret = daemonStub_->HandleGetConnectedDeviceList(data, reply);
750 EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
751
752 DfsDeviceInfo testDevice;
753 testDevice.networkId_ = "networkId";
754 std::vector<DfsDeviceInfo> deviceList = {testDevice};
755 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true))
756 .WillOnce(Return(true));
757 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
758 EXPECT_CALL(*daemonStub_, GetConnectedDeviceList(_)).WillOnce(DoAll(SetArgReferee<0>(deviceList), Return(E_OK)));
759 ret = daemonStub_->HandleGetConnectedDeviceList(data, reply);
760 EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
761
762 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true))
763 .WillOnce(Return(true));
764 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false));
765 EXPECT_CALL(*daemonStub_, GetConnectedDeviceList(_)).WillOnce(DoAll(SetArgReferee<0>(deviceList), Return(E_OK)));
766 ret = daemonStub_->HandleGetConnectedDeviceList(data, reply);
767 EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
768
769 EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true))
770 .WillOnce(Return(true));
771 EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true));
772 EXPECT_CALL(*daemonStub_, GetConnectedDeviceList(_)).WillOnce(DoAll(SetArgReferee<0>(deviceList), Return(E_OK)));
773 ret = daemonStub_->HandleGetConnectedDeviceList(data, reply);
774 EXPECT_EQ(ret, E_OK);
775 GTEST_LOG_(INFO) << "DaemonStubSupHandleGetConnectedDeviceList End";
776 }
777 } // namespace OHOS::Storage::DistributedFile::Test