• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 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 
16 #include <gtest/gtest.h>
17 #include <singleton.h>
18 #include <cassert>
19 #include <sys/types.h>
20 #include <sys/stat.h>
21 #include <fcntl.h>
22 #include <string>
23 #include <vector>
24 #include <unordered_map>
25 
26 #include "remote_file_share.h"
27 #include "remote_file_share.cpp"
28 
29 namespace {
30     using namespace std;
31     using namespace OHOS::AppFileService::ModuleRemoteFileShare;
32 
33     const int E_INVALID_ARGUMENT = 22;
34     const int E_OK = 0;
35     const int USER_ID = 100;
36 
37     class RemoteFileShareTest : public testing::Test {
38     public:
SetUpTestCase(void)39         static void SetUpTestCase(void) {};
TearDownTestCase()40         static void TearDownTestCase() {};
SetUp()41         void SetUp() {};
TearDown()42         void TearDown() {};
43     };
44 
45     /**
46      * @tc.name: remote_file_share_test_0000
47      * @tc.desc: Test function of RemoteFileShare() interface for SUCCESS.
48      * @tc.size: MEDIUM
49      * @tc.type: FUNC
50      * @tc.level Level 1
51      * @tc.require: SR000H63TL
52      */
53     HWTEST_F(RemoteFileShareTest, Remote_file_share_RemoteFileShare_0000, testing::ext::TestSize.Level1)
54     {
55         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin Remote_file_share_RemoteFileShare_0000";
56         RemoteFileShare* test = new RemoteFileShare;
57         ASSERT_TRUE(test != nullptr) << "RemoteFileShare Construct Failed!";
58         delete test;
59         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_RemoteFileShare_0000";
60     }
61 
62     /**
63      * @tc.name: remote_file_share_test_0001
64      * @tc.desc: Test function of CreateSharePath() interface for SUCCESS.
65      * @tc.size: MEDIUM
66      * @tc.type: FUNC
67      * @tc.level Level 1
68      * @tc.require: SR000H63TL
69      */
70     HWTEST_F(RemoteFileShareTest, Remote_file_share_CreateSharePath_0001, testing::ext::TestSize.Level1)
71     {
72         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin Remote_file_share_CreateSharePath_0001";
73         const int fd = -1;
74         const int userId = 100;
75         const string deviceId = "0";
76         string sharePath = "";
77         int ret = RemoteFileShare::CreateSharePath(fd, sharePath, userId, deviceId);
78         EXPECT_EQ(ret, E_INVALID_ARGUMENT);
79         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_CreateSharePath_0001";
80     }
81 
82     /**
83      * @tc.name: remote_file_share_test_0002
84      * @tc.desc: Test function of CreateSharePath() interface for SUCCESS.
85      * @tc.size: MEDIUM
86      * @tc.type: FUNC
87      * @tc.level Level 1
88      * @tc.require: SR000H63TL
89      */
90     HWTEST_F(RemoteFileShareTest, Remote_file_share_CreateSharePath_0002, testing::ext::TestSize.Level1)
91     {
92         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin Remote_file_share_CreateSharePath_0002";
93         const int fd = 10;
94         const int userId = 90;
95         const string deviceId = "0";
96         string sharePath = "";
97         int ret = RemoteFileShare::CreateSharePath(fd, sharePath, userId, deviceId);
98         EXPECT_EQ(ret, E_INVALID_ARGUMENT);
99         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_CreateSharePath_0002";
100     }
101 
102     /**
103      * @tc.name: remote_file_share_test_0003
104      * @tc.desc: Test function of CreateSharePath() interface for SUCCESS.
105      * @tc.size: MEDIUM
106      * @tc.type: FUNC
107      * @tc.level Level 1
108      * @tc.require: SR000H63TL
109      */
110     HWTEST_F(RemoteFileShareTest, Remote_file_share_CreateSharePath_0003, testing::ext::TestSize.Level1)
111     {
112         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_CreateSharePath_0003";
113         const int fd = 10;
114         const int userId = 100;
115         const string deviceId = "00";
116         string sharePath = "";
117         int ret = RemoteFileShare::CreateSharePath(fd, sharePath, userId, deviceId);
118         EXPECT_EQ(ret, E_INVALID_ARGUMENT);
119         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_CreateSharePath_0003";
120     }
121 
122     /**
123      * @tc.name: remote_file_share_test_0004
124      * @tc.desc: Test function of CreateSharePath() interface for SUCCESS.
125      * @tc.size: MEDIUM
126      * @tc.type: FUNC
127      * @tc.level Level 1
128      * @tc.require: SR000H63TL
129      */
130     HWTEST_F(RemoteFileShareTest, Remote_file_share_CreateSharePath_0004, testing::ext::TestSize.Level1)
131     {
132         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_CreateSharePath_0004";
133         const string fileStr = "/data/test/remote_file_share_test.txt";
134         int fd = open(fileStr.c_str(), O_RDWR);
135         ASSERT_TRUE(fd != -1) << "RemoteFileShareTest Create File Failed!";
136         const int userId = 100;
137         const string deviceId = "0";
138         string sharePath = "";
139         int ret = RemoteFileShare::CreateSharePath(fd, sharePath, userId, deviceId);
140         close(fd);
141         EXPECT_EQ(ret, E_OK);
142         GTEST_LOG_(INFO) << "RemoteFileShareTest Create Share Path " << sharePath;
143         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_CreateSharePath_0004";
144     }
145 
146     /**
147      * @tc.name: remote_file_share_test_0005
148      * @tc.desc: Test function of CreateSharePath() interface for SUCCESS.
149      * @tc.size: MEDIUM
150      * @tc.type: FUNC
151      * @tc.level Level 1
152      * @tc.require: SR000H63TL
153      */
154     HWTEST_F(RemoteFileShareTest, Remote_file_share_CreateSharePath_0005, testing::ext::TestSize.Level1)
155     {
156         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_CreateSharePath_0005";
157         const string fileStr = "/data/test/remote_file_share_test.txt";
158         int fd = open(fileStr.c_str(), O_RDWR);
159         ASSERT_TRUE(fd != -1) << "RemoteFileShareTest Create File Failed!";
160         const int userId = 100;
161         const string deviceId = "0";
162         string sharePath = "";
163         char pthreadName[PATH_MAX];
164         int ret = pthread_getname_np(pthread_self(), pthreadName, sizeof(pthreadName));
165         EXPECT_EQ(ret, E_OK);
166         string pthreadNameStr = pthreadName;
167         string errPthreadName = "../test";
168         ret = pthread_setname_np(pthread_self(), errPthreadName.c_str());
169         EXPECT_EQ(ret, E_OK);
170         ret = RemoteFileShare::CreateSharePath(fd, sharePath, userId, deviceId);
171         close(fd);
172         EXPECT_NE(ret, E_OK);
173         ret = pthread_setname_np(pthread_self(), pthreadNameStr.c_str());
174         EXPECT_EQ(ret, E_OK);
175         GTEST_LOG_(INFO) << "RemoteFileShareTest Create Share Path " << sharePath;
176         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_CreateSharePath_0005";
177     }
178 
179     /**
180      * @tc.name: remote_file_share_test_0005
181      * @tc.desc: Test function of GetDfsUriFromLocal() interface for SUCCESS.
182      * @tc.size: MEDIUM
183      * @tc.type: FUNC
184      * @tc.level Level 1
185      * @tc.require: I7KDF7
186      */
187     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0005, testing::ext::TestSize.Level1)
188     {
189         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0005";
190         const string dirPath = "/data/app/el2/100/base/com.demo.a/";
191         const string uriStr = "file://com.demo.a/data/storage/el2/base/remote_file_share_test.txt";
192         const string fileStr = "/data/app/el2/100/base/com.demo.a/remote_file_share_test.txt";
193         const int userId = 100;
194 
195         int ret = mkdir(dirPath.c_str(), S_IRWXU | S_IRWXG | S_IXOTH);
196         ASSERT_TRUE((ret != -1) || (ret == -1 && errno == EEXIST)) << "RemoteFileShareTest mkdir failed! " << errno;
197 
198         int fd = open(fileStr.c_str(), O_RDWR | O_CREAT);
199         ASSERT_TRUE(fd != -1) << "Failed to open file in RemoteFileShareTest! " << errno;
200         close(fd);
201 
202         HmdfsUriInfo hui;
203         ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
204         EXPECT_EQ(ret, E_OK);
205 
206         ret = unlink(fileStr.c_str());
207         ASSERT_TRUE(ret != -1) << "Failed to delete file in RemoteFileShareTest! " << errno;
208 
209         ret = rmdir(dirPath.c_str());
210         ASSERT_TRUE(ret != -1) << "RemoteFileShareTest rmdir failed! " << errno;
211         GTEST_LOG_(INFO) << "RemoteFileShareTest uri is " << hui.uriStr;
212         GTEST_LOG_(INFO) << "RemoteFileShareTest file size is " << hui.fileSize;
213         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0005";
214     }
215 
216     /**
217      * @tc.name: remote_file_share_test_0006
218      * @tc.desc: Test function of GetDfsUriFromLocal() interface for FAILURE.
219      * @tc.size: MEDIUM
220      * @tc.type: FUNC
221      * @tc.level Level 1
222      * @tc.require: I7KDF7
223      */
224     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0006, testing::ext::TestSize.Level1)
225     {
226         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0006";
227         const string uriStr = "";
228         const int userId = 100;
229         HmdfsUriInfo hui;
230         int ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
231         EXPECT_EQ(ret, -EINVAL);
232 
233         vector<string> uriList;
234         unordered_map<string, HmdfsUriInfo> uriToDfsUriMaps;
235         uriList.push_back(uriStr);
236         ret = RemoteFileShare::GetDfsUrisFromLocal(uriList, userId, uriToDfsUriMaps);
237         EXPECT_EQ(ret, -EINVAL);
238 
239         GTEST_LOG_(INFO) << "RemoteFileShareTest uri is " << hui.uriStr;
240         GTEST_LOG_(INFO) << "RemoteFileShareTest file size is " << hui.fileSize;
241         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0006";
242     }
243 
244     /**
245      * @tc.name: remote_file_share_test_0007
246      * @tc.desc: Test function of GetDfsUriFromLocal() interface for FAILURE.
247      * @tc.size: MEDIUM
248      * @tc.type: FUNC
249      * @tc.level Level 1
250      * @tc.require: I7KDF7
251      */
252     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0007, testing::ext::TestSize.Level1)
253     {
254         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0007";
255         const string uriStr = "file://com.demo.a/./data/storage/el2/base/remote_file_share_test.txt";
256         const int userId = 100;
257         HmdfsUriInfo hui;
258         int ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
259         EXPECT_EQ(ret, -EINVAL);
260 
261         vector<string> uriList;
262         unordered_map<string, HmdfsUriInfo> uriToDfsUriMaps;
263         uriList.push_back(uriStr);
264         ret = RemoteFileShare::GetDfsUrisFromLocal(uriList, userId, uriToDfsUriMaps);
265         EXPECT_EQ(ret, -EINVAL);
266 
267         GTEST_LOG_(INFO) << "RemoteFileShareTest uri is " << hui.uriStr;
268         GTEST_LOG_(INFO) << "RemoteFileShareTest file size is " << hui.fileSize;
269         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0007";
270     }
271 
272     /**
273      * @tc.name: remote_file_share_test_0008
274      * @tc.desc: Test function of GetDfsUriFromLocal() interface for FAILURE.
275      * @tc.size: MEDIUM
276      * @tc.type: FUNC
277      * @tc.level Level 1
278      * @tc.require: I7KDF7
279      */
280     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0008, testing::ext::TestSize.Level1)
281     {
282         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0008";
283         const string uriStr = "file://com.demo.a/../data/storage/el2/base/remote_file_share_test.txt";
284         const int userId = 100;
285         HmdfsUriInfo hui;
286         int ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
287         EXPECT_EQ(ret, -EINVAL);
288 
289         vector<string> uriList;
290         unordered_map<string, HmdfsUriInfo> uriToDfsUriMaps;
291         uriList.push_back(uriStr);
292         ret = RemoteFileShare::GetDfsUrisFromLocal(uriList, userId, uriToDfsUriMaps);
293         EXPECT_EQ(ret, -EINVAL);
294 
295         GTEST_LOG_(INFO) << "RemoteFileShareTest uri is " << hui.uriStr;
296         GTEST_LOG_(INFO) << "RemoteFileShareTest file size is " << hui.fileSize;
297         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0008";
298     }
299 
300      /**
301      * @tc.name: remote_file_share_test_0009
302      * @tc.desc: Test function of GetDfsUriFromLocal() interface for FAILURE.
303      * @tc.size: MEDIUM
304      * @tc.type: FUNC
305      * @tc.level Level 1
306      * @tc.require: I7KDF7
307      */
308     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0009, testing::ext::TestSize.Level1)
309     {
310         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0009";
311         const string uriStr = "file://com.demo.a/data/storage/el3/base/remote_file_share_test.txt";
312         const int userId = 100;
313         HmdfsUriInfo hui;
314         int ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
315         EXPECT_EQ(ret, -EINVAL);
316 
317         vector<string> uriList;
318         unordered_map<string, HmdfsUriInfo> uriToDfsUriMaps;
319         uriList.push_back(uriStr);
320         ret = RemoteFileShare::GetDfsUrisFromLocal(uriList, userId, uriToDfsUriMaps);
321         EXPECT_EQ(ret, -EINVAL);
322 
323         GTEST_LOG_(INFO) << "RemoteFileShareTest uri is " << hui.uriStr;
324         GTEST_LOG_(INFO) << "RemoteFileShareTest file size is " << hui.fileSize;
325         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0009";
326     }
327 
328     /**
329      * @tc.name: remote_file_share_test_0010
330      * @tc.desc: Test function of GetDfsUriFromLocal() interface for FAILURE.
331      * @tc.size: MEDIUM
332      * @tc.type: FUNC
333      * @tc.level Level 1
334      * @tc.require: I7KDF7
335      */
336     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0010, testing::ext::TestSize.Level1)
337     {
338         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0010";
339         const string uriStr = "file://com.demo.a/data/storage/el2/base/notExistFile.txt";
340         const int userId = 100;
341         HmdfsUriInfo hui;
342         int ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
343         EXPECT_NE(ret, E_OK);
344 
345         vector<string> uriList;
346         unordered_map<string, HmdfsUriInfo> uriToDfsUriMaps;
347         uriList.push_back(uriStr);
348         ret = RemoteFileShare::GetDfsUrisFromLocal(uriList, userId, uriToDfsUriMaps);
349         EXPECT_NE(ret, E_OK);
350 
351         GTEST_LOG_(INFO) << "RemoteFileShareTest uri is " << hui.uriStr;
352         GTEST_LOG_(INFO) << "RemoteFileShareTest file size is " << hui.fileSize;
353         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0010";
354     }
355 
356     /**
357      * @tc.name: remote_file_share_test_0011
358      * @tc.desc: Test function of GetDfsUriFromLocal() interface for SUCCESS.
359      *           the file name is chinese which has been encoded
360      * @tc.size: MEDIUM
361      * @tc.type: FUNC
362      * @tc.level Level 1
363      * @tc.require: I7KDF7
364      */
365     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0011, testing::ext::TestSize.Level1)
366     {
367         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0011";
368         const string dirPath = "/data/app/el2/100/base/com.demo.a/";
369         const string uriStr = "file://com.demo.a/data/storage/el2/base/"
370             "%E5%85%B1%20%E4%BA%AB%20%E6%96%87%20%E4%BB%B6%20%E6%B5%8B%20%E8%AF%95.txt";
371         const string fileStr = "/data/app/el2/100/base/com.demo.a/共 享 文 件 测 试.txt";
372         const int userId = 100;
373 
374         int ret = mkdir(dirPath.c_str(), S_IRWXU | S_IRWXG | S_IXOTH);
375         ASSERT_TRUE((ret != -1) || (ret == -1 && errno == EEXIST)) << "RemoteFileShareTest mkdir failed! " << errno;
376 
377         int fd = open(fileStr.c_str(), O_RDWR | O_CREAT);
378         ASSERT_TRUE(fd != -1) << "RemoteFileShareTest open file failed! " << errno;
379         close(fd);
380 
381         HmdfsUriInfo hui;
382         ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
383         EXPECT_EQ(ret, E_OK);
384         ret = unlink(fileStr.c_str());
385         ASSERT_TRUE(ret != -1) << "RemoteFileShareTest delete file failed! " << errno;
386 
387         ret = rmdir(dirPath.c_str());
388         ASSERT_TRUE(ret != -1) << "RemoteFileShareTest rmdir failed! " << errno;
389 
390         vector<string> uriList;
391         unordered_map<string, HmdfsUriInfo> uriToDfsUriMaps;
392         uriList.push_back(uriStr);
393         ret = RemoteFileShare::GetDfsUrisFromLocal(uriList, userId, uriToDfsUriMaps);
394         EXPECT_NE(ret, E_OK);
395 
396         GTEST_LOG_(INFO) << "RemoteFileShareTest uri is " << hui.uriStr;
397         GTEST_LOG_(INFO) << "RemoteFileShareTest file size is " << hui.fileSize;
398         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0011";
399     }
400 
401     /**
402      * @tc.name: Remote_file_share_GetDfsUriFromLocal_0012
403      * @tc.desc: Test function of GetDfsUriFromLocal() interface for FAILURE.
404      *           the file name is chinese which has been encoded
405      * @tc.size: MEDIUM
406      * @tc.type: FUNC
407      * @tc.level Level 1
408      * @tc.require: I7KDF7
409      */
410     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0012, testing::ext::TestSize.Level1)
411     {
412         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0012";
413         string uriStr = "datashare://media/Photo/12/IMG_12345_0011/test.jpg";
414         const int userId = 100;
415 
416         HmdfsUriInfo hui;
417         auto ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
418         EXPECT_EQ(ret, -EINVAL);
419 
420         uriStr = "datashare://media/Photo/12/IMG_12345_0011/test.jpg/others";
421         ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
422         EXPECT_EQ(ret, -EINVAL);
423         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0012";
424     }
425 
426     /**
427      * @tc.name: Remote_file_share_GetDfsUriFromLocal_0013
428      * @tc.desc: Test function of GetDfsUriFromLocal() interface for SUCCESS.
429      *           the file name is chinese which has been encoded
430      * @tc.size: MEDIUM
431      * @tc.type: FUNC
432      * @tc.level Level 1
433      * @tc.require: I7KDF7
434      */
435     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0013, testing::ext::TestSize.Level1)
436     {
437         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0013";
438         const string uriStr = "file://media/Photo/12/IMG_12345_0011/test.jpg";
439         const int userId = 100;
440 
441         HmdfsUriInfo hui;
442         auto ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
443         EXPECT_NE(ret, 0);
444         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0013";
445     }
446 
447     /**
448      * @tc.name: Remote_file_share_GetDfsUriFromLocal_0014
449      * @tc.desc: Test function of GetDfsUriFromLocal() interface for SUCCESS.
450      *           the file name is chinese which has been encoded
451      * @tc.size: MEDIUM
452      * @tc.type: FUNC
453      * @tc.level Level 1
454      * @tc.require: I7KDF7
455      */
456     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0014, testing::ext::TestSize.Level1)
457     {
458         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0014";
459         const string uriStr = "file://docs/storage/Users/currentUser/Documents/1.txt";
460         const int userId = 100;
461 
462         HmdfsUriInfo hui;
463         auto ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
464         EXPECT_EQ(ret, E_OK);
465         EXPECT_EQ(hui.fileSize, 0);
466         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0014";
467     }
468 
469     /**
470      * @tc.name: remote_file_share_GetDfsUriFromLocal_0015
471      * @tc.desc: Test function of GetDfsUrisFromLocal() interface.
472      * @tc.size: MEDIUM
473      * @tc.type: FUNC
474      * @tc.level Level 1
475      * @tc.require: I7KDF7
476      */
477     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0015, testing::ext::TestSize.Level1)
478     {
479         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0015";
480         const string uriStr = "file://media/Photo/12/IMG_12345_0011/test.jpg";
481         const int userId = USER_ID;
482         HmdfsUriInfo hui;
483         int ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
484         EXPECT_NE(ret, E_OK);
485 
486         vector<string> uriList;
487         unordered_map<string, HmdfsUriInfo> uriToDfsUriMaps;
488         uriList.push_back(uriStr);
489         ret = RemoteFileShare::GetDfsUrisFromLocal(uriList, userId, uriToDfsUriMaps);
490         EXPECT_NE(ret, E_OK);
491 
492         GTEST_LOG_(INFO) << "RemoteFileShareTest uri is " << hui.uriStr;
493         GTEST_LOG_(INFO) << "RemoteFileShareTest file size is " << hui.fileSize;
494         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0015";
495     }
496 
497     /**
498      * @tc.name: remote_file_share_GetDfsUriFromLocal_0016
499      * @tc.desc: Test function of GetDfsUrisFromLocal() interface.
500      * @tc.size: MEDIUM
501      * @tc.type: FUNC
502      * @tc.level Level 1
503      * @tc.require: I7KDF7
504      */
505     HWTEST_F(RemoteFileShareTest, Remote_file_share_GetDfsUriFromLocal_0016, testing::ext::TestSize.Level1)
506     {
507         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_GetDfsUriFromLocal_0016";
508         const string uriStr = "file://docs/storage/Users/currentUser/Documents/1.txt";
509         const int userId = USER_ID;
510         HmdfsUriInfo hui;
511         int ret = RemoteFileShare::GetDfsUriFromLocal(uriStr, userId, hui);
512         EXPECT_EQ(ret, E_OK);
513 
514         vector<string> uriList;
515         unordered_map<string, HmdfsUriInfo> uriToDfsUriMaps;
516         uriList.push_back(uriStr);
517         ret = RemoteFileShare::GetDfsUrisFromLocal(uriList, userId, uriToDfsUriMaps);
518         EXPECT_EQ(ret, E_OK);
519 
520         GTEST_LOG_(INFO) << "RemoteFileShareTest uri is " << hui.uriStr;
521         GTEST_LOG_(INFO) << "RemoteFileShareTest file size is " << hui.fileSize;
522         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_GetDfsUriFromLocal_0016";
523     }
524 
525     /**
526      * @tc.name: remote_file_share_test_0012
527      * @tc.desc: Test function of TransRemoteUriToLocal() interface for SUCCESS.
528      * @tc.size: MEDIUM
529      * @tc.type: FUNC
530      * @tc.level Level 1
531      * @tc.require: I7KDF7
532      */
533     HWTEST_F(RemoteFileShareTest, Remote_file_share_TransRemoteUriToLocal_0012, testing::ext::TestSize.Level1)
534     {
535         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_TransRemoteUriToLocal_0012";
536         const vector<string> uriList = {"file://docs/storage/Users/currentUser/Document/1.txt",
537                                         "file://docs/storage/Users/currentUser/Download/Subject/2.jpg",
538                                         "file://docs/storage/Users/currentUser/Document/Subject1/Subject2/1.txt",
539                                         "file://docs/storage/100/account/Document/Subject1/Subject2/1.txt"};
540         const vector<string> expectedList = {"file://docs/storage/hmdfs/001/Document/1.txt",
541                                              "file://docs/storage/hmdfs/001/Download/Subject/2.jpg",
542                                              "file://docs/storage/hmdfs/001/Document/Subject1/Subject2/1.txt",
543                                              "file://docs/storage/hmdfs/001/Document/Subject1/Subject2/1.txt"};
544         const string networkId = "100";
545         const string deviceId = "001";
546         vector<string> resultList;
547         int ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
548         EXPECT_EQ(ret, E_OK);
549         EXPECT_EQ(resultList, expectedList);
550 
551         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_TransRemoteUriToLocal_0012";
552     }
553 
554     /**
555      * @tc.name: remote_file_share_test_0013
556      * @tc.desc: Test function of TransRemoteUriToLocal() interface for FAILURE.
557      *           the sandboxPath of uri does not equal to "storage"
558      * @tc.size: MEDIUM
559      * @tc.type: FUNC
560      * @tc.level Level 1
561      * @tc.require: I7KDF7
562      */
563     HWTEST_F(RemoteFileShareTest, Remote_file_share_TransRemoteUriToLocal_0013, testing::ext::TestSize.Level1)
564     {
565         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_TransRemoteUriToLocal_0013";
566         const vector<string> uriList = {"file://docs/storage/Users/currentUser/Document/1.txt",
567                                         "file://docs/hmdfs/Users/currentUser/Download/Subject/2.jpg",
568                                         "file://docs/tmp/Users/currentUser/Document/Subject1/Subject2/1.txt",
569                                         "file://docs/storage/100/account/Document/Subject1/Subject2/1.txt"};
570         const string networkId = "100";
571         const string deviceId = "001";
572         vector<string> resultList;
573         int ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
574         EXPECT_NE(ret, E_OK);
575         EXPECT_EQ(resultList, uriList);
576 
577         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_TransRemoteUriToLocal_0013";
578     }
579 
580     /**
581      * @tc.name: remote_file_share_test_0014
582      * @tc.desc: Test function of TransRemoteUriToLocal() interface for FAILURE.
583      *           the bundlename of uri does not equal to "docs"
584      * @tc.size: MEDIUM
585      * @tc.type: FUNC
586      * @tc.level Level 1
587      * @tc.require: I7KDF7
588      */
589     HWTEST_F(RemoteFileShareTest, Remote_file_share_TransRemoteUriToLocal_0014, testing::ext::TestSize.Level1)
590     {
591         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_TransRemoteUriToLocal_0014";
592         const vector<string> uriList = {"file://docs/storage/Users/currentUser/Document/1.txt",
593                                         "file://doc/storage/Users/currentUser/Download/Subject/2.jpg",
594                                         "file://docs/storage/Users/currentUser/Document/Subject1/Subject2/1.txt",
595                                         "file://doc/storage/100/account/Document/Subject1/Subject2/1.txt"};
596         const string networkId = "100";
597         const string deviceId = "001";
598         vector<string> resultList;
599         int ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
600         EXPECT_NE(ret, E_OK);
601         EXPECT_EQ(resultList, uriList);
602 
603         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_TransRemoteUriToLocal_0014";
604     }
605 
606     /**
607      * @tc.name: remote_file_share_test_0015
608      * @tc.desc: Test function of TransRemoteUriToLocal() interface for FAILURE.
609      *           the scheme of uri does not equal to "file"
610      * @tc.size: MEDIUM
611      * @tc.type: FUNC
612      * @tc.level Level 1
613      * @tc.require: I7KDF7
614      */
615     HWTEST_F(RemoteFileShareTest, Remote_file_share_TransRemoteUriToLocal_0015, testing::ext::TestSize.Level1)
616     {
617         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_TransRemoteUriToLocal_0015";
618         const vector<string> uriList = {"FILE://docs/storage/Users/currentUser/Document/1.txt",
619                                         "file://docs/storage/Users/currentUser/Download/Subject/2.jpg",
620                                         "file://docs/storage/Users/currentUser/Document/Subject1/Subject2/1.txt",
621                                         "file://docs/storage/100/account/Document/Subject1/Subject2/1.txt"};
622         const string networkId = "100";
623         const string deviceId = "001";
624         vector<string> resultList;
625         int ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
626         EXPECT_NE(ret, E_OK);
627         EXPECT_EQ(resultList, uriList);
628 
629         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_TransRemoteUriToLocal_0015";
630     }
631 
632     /**
633      * @tc.name: remote_file_share_test_0016
634      * @tc.desc: Test function of TransRemoteUriToLocal() interface for FAILURE.
635      *           the inpute param is invalid
636      * @tc.size: MEDIUM
637      * @tc.type: FUNC
638      * @tc.level Level 1
639      * @tc.require: I7KDF7
640      */
641     HWTEST_F(RemoteFileShareTest, Remote_file_share_TransRemoteUriToLocal_0016, testing::ext::TestSize.Level1)
642     {
643         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  Remote_file_share_TransRemoteUriToLocal_0016";
644         const vector<string> uriList = {"FILE://docs/storage/Users/currentUser/Document/1.txt",
645                                         "file://docs/storage/Users/currentUser/Download/Subject/2.jpg",
646                                         "file://docs/storage/Users/currentUser/Document/Subject1/Subject2/1.txt",
647                                         "file://docs/storage/100/account/Document/Subject1/Subject2/1.txt"};
648         string networkId = "";
649         string deviceId = "001";
650         vector<string> resultList;
651         int ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
652         EXPECT_EQ(ret, EINVAL);
653 
654         networkId = "100";
655         deviceId = "";
656         ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
657         EXPECT_EQ(ret, EINVAL);
658 
659         networkId = "";
660         deviceId = "";
661         ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
662         EXPECT_EQ(ret, EINVAL);
663         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_TransRemoteUriToLocal_0016";
664     }
665 
666     /**
667      * @tc.name: remote_file_share_test_0017
668      * @tc.desc: Test function of TransRemoteUriToLocal() interface for FAILURE.
669      *           the inpute param is invalid
670      * @tc.size: MEDIUM
671      * @tc.type: FUNC
672      * @tc.level Level 1
673      * @tc.require: I7KDF7
674      */
675     HWTEST_F(RemoteFileShareTest, remote_file_share_test_0017, testing::ext::TestSize.Level1)
676     {
677         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin  remote_file_share_test_0017";
678         vector<string> uriList = {"file://docs/storage/Users/currentUser/./Document/1.txt"};
679         const string networkId = "100";
680         const string deviceId = "001";
681         vector<string> resultList;
682         int ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
683         EXPECT_NE(ret, EINVAL);
684 
685         uriList[0].clear();
686         uriList[0] = "datashare://docs/storage/Users/currentUser/Document/1.txt";
687         ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
688         EXPECT_NE(ret, EINVAL);
689 
690         uriList[0].clear();
691         uriList[0] = "file://media/Photo/12/IMG_12345_0011/test.jpg";
692         ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
693         EXPECT_NE(ret, EINVAL);
694 
695         uriList[0].clear();
696         uriList[0] = "file://docs/test/";
697         ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
698         EXPECT_NE(ret, EINVAL);
699 
700         uriList[0].clear();
701         uriList[0] = "file://docs/storage/";
702         ret = RemoteFileShare::TransRemoteUriToLocal(uriList, networkId, deviceId, resultList);
703         EXPECT_NE(ret, EINVAL);
704         GTEST_LOG_(INFO) << "RemoteFileShareTest-end remote_file_share_test_0017";
705     }
706 
707     /**
708      * @tc.name: remote_file_share_test_0000
709      * @tc.desc: Test function of RemoteFileShare() interface for SUCCESS.
710      * @tc.size: MEDIUM
711      * @tc.type: FUNC
712      * @tc.level Level 1
713      * @tc.require: SR000H63TL
714      */
715     HWTEST_F(RemoteFileShareTest, Remote_file_share_DeleteShareDir_0000, testing::ext::TestSize.Level1)
716     {
717         GTEST_LOG_(INFO) << "RemoteFileShareTest-begin Remote_file_share_DeleteShareDir_0000";
718         string packagePath = "/data/filetest";
719         string sharePath = "/data/filetest";
720         EXPECT_EQ(true, DeleteShareDir(packagePath, sharePath));
721         GTEST_LOG_(INFO) << "RemoteFileShareTest-end Remote_file_share_DeleteShareDir_0000";
722 }
723 }
724