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 "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 "dfs_error.h"
24 #include "dfsu_access_token_helper.h"
25 #include "file_dfs_listener_mock.h"
26 #include "ipc/hmdfs_info.h"
27 #include "ipc/distributed_file_daemon_ipc_interface_code.h"
28 #include "i_daemon_mock.h"
29 #include "message_parcel_mock.h"
30 #include "utils_log.h"
31 
32 namespace {
33     bool g_getCallingUidTrue = true;
34     bool g_checkUriPermissionTrue = true;
35     bool g_checkCallerPermissionTrue = true;
36     constexpr pid_t DATA_UID = 3012;
37     constexpr pid_t DAEMON_UID = 1009;
38     static pid_t UID = DAEMON_UID;
39 }
40 
41 namespace OHOS {
42 #ifdef CONFIG_IPC_SINGLE
43 using namespace IPC_SINGLE;
44 #endif
GetCallingUid()45 pid_t IPCSkeleton::GetCallingUid()
46 {
47     if (!g_getCallingUidTrue) {
48         return -1;
49     }
50 
51     return UID;
52 }
53 }
54 
55 namespace OHOS::FileManagement {
CheckUriPermission(const std::string & uriStr)56 bool DfsuAccessTokenHelper::CheckUriPermission(const std::string &uriStr)
57 {
58     if (g_checkUriPermissionTrue) {
59         return true;
60     }
61 
62     return false;
63 }
64 
CheckCallerPermission(const std::string & permissionName)65 bool DfsuAccessTokenHelper::CheckCallerPermission(const std::string &permissionName)
66 {
67     if (g_checkCallerPermissionTrue) {
68         return true;
69     }
70 
71     return false;
72 }
73 }
74 
75 namespace OHOS::Storage::DistributedFile::Test {
76 using namespace testing;
77 using namespace testing::ext;
78 using namespace std;
79 using namespace OHOS::FileManagement;
80 
81 class MockDaemonSupStub : public DaemonStub {
82 public:
83     MOCK_METHOD1(OpenP2PConnection, int32_t(const DistributedHardware::DmDeviceInfo &deviceInfo));
84     MOCK_METHOD1(CloseP2PConnection, int32_t(const DistributedHardware::DmDeviceInfo &deviceInfo));
85     MOCK_METHOD2(OpenP2PConnectionEx, int32_t(const std::string &networkId, sptr<IFileDfsListener> remoteReverseObj));
86     MOCK_METHOD1(CloseP2PConnectionEx, int32_t(const std::string &networkId));
87     MOCK_METHOD4(RequestSendFile,
88                  int32_t(const std::string &srcUri,
89                          const std::string &dstPath,
90                          const std::string &remoteDeviceId,
91                          const std::string &sessionName));
92     MOCK_METHOD5(PrepareSession,
93                  int32_t(const std::string &srcUri,
94                          const std::string &dstUri,
95                          const std::string &srcDeviceId,
96                          const sptr<IRemoteObject> &listener,
97                          HmdfsInfo &fileInfo));
98     MOCK_METHOD1(CancelCopyTask, int32_t(const std::string &sessionName));
99     MOCK_METHOD3(GetRemoteCopyInfo, int32_t(const std::string &srcUri, bool &isFile, bool &isDir));
100     MOCK_METHOD3(PushAsset, int32_t(int32_t userId,
101                                     const sptr<AssetObj> &assetObj,
102                                     const sptr<IAssetSendCallback> &sendCallback));
103     MOCK_METHOD1(RegisterAssetCallback, int32_t(const sptr<IAssetRecvCallback> &recvCallback));
104     MOCK_METHOD1(UnRegisterAssetCallback, int32_t(const sptr<IAssetRecvCallback> &recvCallback));
105 };
106 
107 class DaemonStubSupPTest : public testing::Test {
108 public:
109     static void SetUpTestCase(void);
110     static void TearDownTestCase(void);
111     void SetUp();
112     void TearDown();
113     static inline std::shared_ptr<MockDaemonSupStub> daemonStub_;
114     static inline shared_ptr<MessageParcelMock> messageParcelMock_ = nullptr;
115 };
116 
SetUpTestCase(void)117 void DaemonStubSupPTest::SetUpTestCase(void)
118 {
119     GTEST_LOG_(INFO) << "SetUpTestCase";
120     daemonStub_ = std::make_shared<MockDaemonSupStub>();
121     messageParcelMock_ = make_shared<MessageParcelMock>();
122     MessageParcelMock::messageParcel = messageParcelMock_;
123 }
124 
TearDownTestCase(void)125 void DaemonStubSupPTest::TearDownTestCase(void)
126 {
127     GTEST_LOG_(INFO) << "TearDownTestCase";
128     daemonStub_ = nullptr;
129     MessageParcelMock::messageParcel = nullptr;
130     messageParcelMock_ = nullptr;
131 }
132 
SetUp(void)133 void DaemonStubSupPTest::SetUp(void)
134 {
135     GTEST_LOG_(INFO) << "SetUp";
136 }
137 
TearDown(void)138 void DaemonStubSupPTest::TearDown(void)
139 {
140     GTEST_LOG_(INFO) << "TearDown";
141 }
142 
143 /**
144  * @tc.name: DaemonStubSupOnRemoteRequestTest001
145  * @tc.desc: Verify the OnRemoteRequest function
146  * @tc.type: FUNC
147  * @tc.require: I7M6L1
148  */
149 HWTEST_F(DaemonStubSupPTest, DaemonStubSupOnRemoteRequestTest001, TestSize.Level1)
150 {
151     GTEST_LOG_(INFO) << "DaemonStubSupOnRemoteRequestTest001 Start";
152     uint32_t code = static_cast<uint32_t>(DistributedFileDaemonInterfaceCode::DISTRIBUTED_FILE_OPEN_P2P_CONNECTION);
153     MessageParcel data;
154     MessageParcel reply;
155     MessageOption option;
156     EXPECT_CALL(*messageParcelMock_, ReadInterfaceToken()).WillOnce(Return(u"test"));
157     auto ret = daemonStub_->OnRemoteRequest(code, data, reply, option);
158     EXPECT_EQ(ret, MockDaemonSupStub::DFS_DAEMON_DESCRIPTOR_IS_EMPTY);
159 
160     EXPECT_CALL(*messageParcelMock_, ReadInterfaceToken()).WillOnce(Return(IDaemon::GetDescriptor()));
161     uint32_t errCode = 65535;
162     ret = daemonStub_->OnRemoteRequest(errCode, data, reply, option);
163     EXPECT_EQ(ret, 305);
164 
165     daemonStub_->opToInterfaceMap_.insert(make_pair(errCode, nullptr));
166     EXPECT_CALL(*messageParcelMock_, ReadInterfaceToken()).WillOnce(Return(IDaemon::GetDescriptor()));
167     ret = daemonStub_->OnRemoteRequest(errCode, data, reply, option);
168     EXPECT_EQ(ret, 305);
169     daemonStub_->opToInterfaceMap_.erase(errCode);
170     GTEST_LOG_(INFO) << "DaemonStubSupOnRemoteRequestTest001 End";
171 }
172 
173 /**
174  * @tc.name: DaemonStubSupHandleOpenP2PConnectionExTest001
175  * @tc.desc: Verify the DaemonStubSupHandleOpenP2PConnectionExTest001 function
176  * @tc.type: FUNC
177  * @tc.require: I7M6L1
178  */
179 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleOpenP2PConnectionExTest001, TestSize.Level1)
180 {
181     GTEST_LOG_(INFO) << "DaemonStubSupHandleOpenP2PConnectionExTest001 Start";
182     MessageParcel data;
183     MessageParcel reply;
184     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
185     auto ret = daemonStub_->HandleOpenP2PConnectionEx(data, reply);
186     EXPECT_EQ(ret, E_IPC_READ_FAILED);
187 
188     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
189     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(nullptr));
190     ret = daemonStub_->HandleOpenP2PConnectionEx(data, reply);
191     EXPECT_EQ(ret, E_IPC_READ_FAILED);
192 
193     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
194     sptr<IRemoteObject> listenerPtr = sptr(new FileDfsListenerMock());
195     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listenerPtr));
196     EXPECT_CALL(*daemonStub_, OpenP2PConnectionEx(_, _)).WillOnce(Return(E_OK));
197     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
198     ret = daemonStub_->HandleOpenP2PConnectionEx(data, reply);
199     EXPECT_EQ(ret, E_OK);
200     GTEST_LOG_(INFO) << "DaemonStubSupHandleOpenP2PConnectionExTest001 End";
201 }
202 
203 /**
204  * @tc.name: DaemonStubSupHandleCloseP2PConnectionExTest001
205  * @tc.desc: Verify the HandleCloseP2PConnectionEx function
206  * @tc.type: FUNC
207  * @tc.require: I7M6L1
208  */
209 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleCloseP2PConnectionExTest001, TestSize.Level1)
210 {
211     GTEST_LOG_(INFO) << "DaemonStubSupHandleCancelCopyTaskTest001 Start";
212     MessageParcel data;
213     MessageParcel reply;
214     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
215     auto ret = daemonStub_->HandleCloseP2PConnectionEx(data, reply);
216     EXPECT_EQ(ret, E_IPC_READ_FAILED);
217 
218     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
219     EXPECT_CALL(*daemonStub_, CloseP2PConnectionEx(_)).WillOnce(Return(E_OK));
220     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
221     ret = daemonStub_->HandleCloseP2PConnectionEx(data, reply);
222     EXPECT_EQ(ret, E_OK);
223     GTEST_LOG_(INFO) << "DaemonStubSupHandleCloseP2PConnectionExTest001 End";
224 }
225 
226 /**
227  * @tc.name: DaemonStubSupHandlePrepareSessionTest001
228  * @tc.desc: Verify the HandlePrepareSession function
229  * @tc.type: FUNC
230  * @tc.require: I7M6L1
231  */
232 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandlePrepareSessionTest001, TestSize.Level1)
233 {
234     GTEST_LOG_(INFO) << "DaemonStubSupHandlePrepareSessionTest001 Start";
235     MessageParcel data;
236     MessageParcel reply;
237 
238     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
239     auto ret = daemonStub_->HandlePrepareSession(data, reply);
240     EXPECT_EQ(ret, E_IPC_READ_FAILED);
241 
242     g_checkUriPermissionTrue = false;
243     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
244     ret = daemonStub_->HandlePrepareSession(data, reply);
245     EXPECT_EQ(ret, E_PERMISSION_DENIED);
246 
247     g_checkUriPermissionTrue = true;
248     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(false));
249     ret = daemonStub_->HandlePrepareSession(data, reply);
250     EXPECT_EQ(ret, E_IPC_READ_FAILED);
251 
252     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
253         .WillOnce(Return(false));
254     ret = daemonStub_->HandlePrepareSession(data, reply);
255     EXPECT_EQ(ret, E_IPC_READ_FAILED);
256 
257     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
258         .WillOnce(Return(true));
259     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(nullptr));
260     ret = daemonStub_->HandlePrepareSession(data, reply);
261     EXPECT_EQ(ret, E_IPC_READ_FAILED);
262 
263     sptr<IRemoteObject> listenerPtr = sptr(new DaemonServiceMock());
264     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
265         .WillOnce(Return(true)).WillOnce(Return(false));
266     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listenerPtr));
267     ret = daemonStub_->HandlePrepareSession(data, reply);
268     EXPECT_EQ(ret, E_IPC_READ_FAILED);
269     GTEST_LOG_(INFO) << "DaemonStubSupHandlePrepareSessionTest001 End";
270 }
271 
272 /**
273  * @tc.name: DaemonStubSupHandlePrepareSessionTest002
274  * @tc.desc: Verify the HandlePrepareSession function
275  * @tc.type: FUNC
276  * @tc.require: I7M6L1
277  */
278 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandlePrepareSessionTest002, TestSize.Level1)
279 {
280     GTEST_LOG_(INFO) << "DaemonStubSupHandlePrepareSessionTest002 Start";
281     MessageParcel data;
282     MessageParcel reply;
283     g_checkUriPermissionTrue = true;
284     sptr<IRemoteObject> listenerPtr = sptr(new DaemonServiceMock());
285     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
286         .WillOnce(Return(true)).WillOnce(Return(true));
287     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listenerPtr));
288     EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(false));
289     auto ret = daemonStub_->HandlePrepareSession(data, reply);
290     EXPECT_EQ(ret, E_IPC_READ_FAILED);
291 
292     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
293         .WillOnce(Return(true)).WillOnce(Return(true));
294     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listenerPtr));
295     EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true));
296     EXPECT_CALL(*daemonStub_, PrepareSession(_, _, _, _, _)).WillOnce(Return(E_INVAL_ARG));
297     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false));
298     ret = daemonStub_->HandlePrepareSession(data, reply);
299     EXPECT_EQ(ret, E_IPC_WRITE_FAILED);
300 
301     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
302         .WillOnce(Return(true)).WillOnce(Return(true));
303     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(listenerPtr));
304     EXPECT_CALL(*messageParcelMock_, ReadBool(_)).WillOnce(Return(true));
305     EXPECT_CALL(*daemonStub_, PrepareSession(_, _, _, _, _)).WillOnce(Return(E_INVAL_ARG));
306     EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true));
307     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
308     ret = daemonStub_->HandlePrepareSession(data, reply);
309     EXPECT_EQ(ret, E_INVAL_ARG);
310     GTEST_LOG_(INFO) << "DaemonStubSupHandlePrepareSessionTest002 End";
311 }
312 
313 /**
314  * @tc.name: DaemonStubSupHandleRequestSendFileTest001
315  * @tc.desc: Verify the HandleRequestSendFile function
316  * @tc.type: FUNC
317  * @tc.require: I7M6L1
318  */
319 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleRequestSendFileTest001, TestSize.Level1)
320 {
321     GTEST_LOG_(INFO) << "DaemonStubSupHandleRequestSendFileTest001 Start";
322     UID = DAEMON_UID;
323     MessageParcel data;
324     MessageParcel reply;
325 
326     g_getCallingUidTrue = false;
327     auto ret = daemonStub_->HandleRequestSendFile(data, reply);
328     EXPECT_EQ(ret, E_PERMISSION_DENIED);
329 
330     g_getCallingUidTrue = true;
331     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
332     ret = daemonStub_->HandleRequestSendFile(data, reply);
333     EXPECT_EQ(ret, E_IPC_READ_FAILED);
334 
335     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(false));
336     ret = daemonStub_->HandleRequestSendFile(data, reply);
337     EXPECT_EQ(ret, E_IPC_READ_FAILED);
338 
339     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
340         .WillOnce(Return(false));
341     ret = daemonStub_->HandleRequestSendFile(data, reply);
342     EXPECT_EQ(ret, E_IPC_READ_FAILED);
343 
344     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
345         .WillOnce(Return(true)).WillOnce(Return(false));
346     ret = daemonStub_->HandleRequestSendFile(data, reply);
347     EXPECT_EQ(ret, E_IPC_READ_FAILED);
348 
349     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true))
350         .WillOnce(Return(true)).WillOnce(Return(true));
351     EXPECT_CALL(*daemonStub_, RequestSendFile(_, _, _, _)).WillOnce(Return(E_INVAL_ARG));
352     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
353     ret = daemonStub_->HandleRequestSendFile(data, reply);
354     EXPECT_EQ(ret, E_INVAL_ARG);
355     GTEST_LOG_(INFO) << "DaemonStubSupHandleRequestSendFileTest001 End";
356 }
357 
358 /**
359  * @tc.name: DaemonStubSupHandleGetRemoteCopyInfoTest001
360  * @tc.desc: Verify the HandleGetRemoteCopyInfo function
361  * @tc.type: FUNC
362  * @tc.require: I7M6L1
363  */
364 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleGetRemoteCopyInfoTest001, TestSize.Level1)
365 {
366     GTEST_LOG_(INFO) << "DaemonStubSupHandleGetRemoteCopyInfoTest001 Start";
367     UID = DAEMON_UID;
368     MessageParcel data;
369     MessageParcel reply;
370     g_getCallingUidTrue = false;
371     auto ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
372     EXPECT_EQ(ret, E_PERMISSION_DENIED);
373 
374     g_getCallingUidTrue = true;
375     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
376     ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
377     EXPECT_EQ(ret, E_IPC_READ_FAILED);
378 
379     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
380     EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_INVAL_ARG));
381     ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
382     EXPECT_EQ(ret, E_IPC_READ_FAILED);
383 
384     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
385     EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_OK));
386     EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false));
387     ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
388     EXPECT_EQ(ret, E_IPC_READ_FAILED);
389 
390     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
391     EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_OK));
392     EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)).WillOnce(Return(false));
393     ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
394     EXPECT_EQ(ret, E_IPC_READ_FAILED);
395 
396     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
397     EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_OK));
398     EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)).WillOnce(Return(true));
399     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
400     ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
401     EXPECT_EQ(ret, E_IPC_READ_FAILED);
402 
403     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
404     EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_OK));
405     EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)).WillOnce(Return(true));
406     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
407     ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
408     EXPECT_EQ(ret, E_OK);
409     GTEST_LOG_(INFO) << "DaemonStubSupHandleGetRemoteCopyInfoTest001 End";
410 }
411 
412 /**
413  * @tc.name: DaemonStubSupHandleGetRemoteCopyInfoTest002
414  * @tc.desc: Verify the HandleGetRemoteCopyInfo function
415  * @tc.type: FUNC
416  * @tc.require: I7M6L1
417  */
418 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleGetRemoteCopyInfoTest002, TestSize.Level1)
419 {
420     GTEST_LOG_(INFO) << "DaemonStubSupHandleGetRemoteCopyInfoTest002 Start";
421     UID = DAEMON_UID;
422     MessageParcel data;
423     MessageParcel reply;
424 
425     g_getCallingUidTrue = true;
426     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
427     EXPECT_CALL(*daemonStub_, GetRemoteCopyInfo(_, _, _)).WillOnce(Return(E_OK));
428     EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)).WillOnce(Return(true));
429     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
430     auto ret = daemonStub_->HandleGetRemoteCopyInfo(data, reply);
431     EXPECT_EQ(ret, E_OK);
432     GTEST_LOG_(INFO) << "DaemonStubSupHandleGetRemoteCopyInfoTest002 End";
433 }
434 
435 /**
436  * @tc.name: DaemonStubSupHandleCancelCopyTaskTest001
437  * @tc.desc: Verify the HandleCancelCopyTask function
438  * @tc.type: FUNC
439  * @tc.require: I7M6L1
440  */
441 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleCancelCopyTaskTest001, TestSize.Level1)
442 {
443     GTEST_LOG_(INFO) << "DaemonStubSupHandleCancelCopyTaskTest001 Start";
444     MessageParcel data;
445     MessageParcel reply;
446     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false));
447     auto ret = daemonStub_->HandleCancelCopyTask(data, reply);
448     EXPECT_EQ(ret, E_IPC_READ_FAILED);
449 
450     EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true));
451     EXPECT_CALL(*daemonStub_, CancelCopyTask(_)).WillOnce(Return(E_OK));
452     ret = daemonStub_->HandleCancelCopyTask(data, reply);
453     EXPECT_EQ(ret, E_OK);
454     GTEST_LOG_(INFO) << "DaemonStubSupHandleCancelCopyTaskTest001 End";
455 }
456 
457 /**
458  * @tc.name: DaemonStubSupHandleRegisterRecvCallback001
459  * @tc.desc: Verify the HandleRegisterRecvCallback function
460  * @tc.type: FUNC
461  * @tc.require: I7M6L1
462  */
463 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleRegisterRecvCallback001, TestSize.Level1)
464 {
465     GTEST_LOG_(INFO) << "DaemonStubSupHandleRegisterRecvCallback001 Start";
466     UID = DATA_UID;
467     MessageParcel data;
468     MessageParcel reply;
469     g_checkCallerPermissionTrue = false;
470     auto ret = daemonStub_->HandleRegisterRecvCallback(data, reply);
471     EXPECT_EQ(ret, E_PERMISSION_DENIED);
472 
473     g_checkCallerPermissionTrue = true;
474     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(nullptr));
475     ret = daemonStub_->HandleRegisterRecvCallback(data, reply);
476     EXPECT_EQ(ret, E_IPC_READ_FAILED);
477 
478     auto recvCallback = sptr(new IAssetRecvCallbackMock());
479     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(recvCallback));
480     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
481     EXPECT_CALL(*daemonStub_, RegisterAssetCallback(_)).WillOnce(Return(E_OK));
482     ret = daemonStub_->HandleRegisterRecvCallback(data, reply);
483     EXPECT_EQ(ret, E_IPC_READ_FAILED);
484 
485     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(recvCallback));
486     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
487     EXPECT_CALL(*daemonStub_, RegisterAssetCallback(_)).WillOnce(Return(E_OK));
488     ret = daemonStub_->HandleRegisterRecvCallback(data, reply);
489     EXPECT_EQ(ret, E_OK);
490     GTEST_LOG_(INFO) << "DaemonStubSupHandleRegisterRecvCallback001 End";
491 }
492 
493 /**
494  * @tc.name: DaemonStubSupHandleUnRegisterRecvCallback001
495  * @tc.desc: Verify the HandleUnRegisterRecvCallback function
496  * @tc.type: FUNC
497  * @tc.require: I7M6L1
498  */
499 HWTEST_F(DaemonStubSupPTest, DaemonStubSupHandleUnRegisterRecvCallback001, TestSize.Level1)
500 {
501     GTEST_LOG_(INFO) << "DaemonStubSupHandleUnRegisterRecvCallback001 Start";
502     UID = DATA_UID;
503     MessageParcel data;
504     MessageParcel reply;
505     g_checkCallerPermissionTrue = false;
506     auto ret = daemonStub_->HandleUnRegisterRecvCallback(data, reply);
507     EXPECT_EQ(ret, E_PERMISSION_DENIED);
508 
509     g_checkCallerPermissionTrue = true;
510     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(nullptr));
511     ret = daemonStub_->HandleUnRegisterRecvCallback(data, reply);
512     EXPECT_EQ(ret, E_IPC_READ_FAILED);
513 
514     auto recvCallback = sptr(new IAssetRecvCallbackMock());
515     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(recvCallback));
516     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false));
517     EXPECT_CALL(*daemonStub_, UnRegisterAssetCallback(_)).WillOnce(Return(E_OK));
518     ret = daemonStub_->HandleUnRegisterRecvCallback(data, reply);
519     EXPECT_EQ(ret, E_IPC_READ_FAILED);
520 
521     EXPECT_CALL(*messageParcelMock_, ReadRemoteObject()).WillOnce(Return(recvCallback));
522     EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true));
523     EXPECT_CALL(*daemonStub_, UnRegisterAssetCallback(_)).WillOnce(Return(E_OK));
524     ret = daemonStub_->HandleUnRegisterRecvCallback(data, reply);
525     EXPECT_EQ(ret, E_OK);
526     GTEST_LOG_(INFO) << "DaemonStubSupHandleUnRegisterRecvCallback001 End";
527 }
528 } // namespace OHOS::Storage::DistributedFile::Test