1 /*
2 * Copyright (c) 2023 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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "directory_ex.h"
20 #include "meta_file.h"
21
22 namespace OHOS::FileManagement::CloudSync::Test {
23 using namespace testing;
24 using namespace testing::ext;
25 using namespace std;
26 constexpr uint32_t TEST_USER_ID = 201;
27 constexpr uint64_t TEST_ISIZE = 1024;
28
29 class DentryMetaFileTest : public testing::Test {
30 public:
31 static void SetUpTestCase(void);
32 static void TearDownTestCase(void);
33 void SetUp();
34 void TearDown();
35 };
SetUpTestCase(void)36 void DentryMetaFileTest::SetUpTestCase(void)
37 {
38 GTEST_LOG_(INFO) << "SetUpTestCase";
39 }
40
TearDownTestCase(void)41 void DentryMetaFileTest::TearDownTestCase(void)
42 {
43 GTEST_LOG_(INFO) << "TearDownTestCase";
44 }
45
SetUp(void)46 void DentryMetaFileTest::SetUp(void)
47 {
48 GTEST_LOG_(INFO) << "SetUp";
49 }
50
TearDown(void)51 void DentryMetaFileTest::TearDown(void)
52 {
53 GTEST_LOG_(INFO) << "TearDown";
54 }
55
56 /**
57 * @tc.name: MetaFileHandleFileByFd001
58 * @tc.desc: Verify the MetaFile::HandleFileByFd function
59 * @tc.type: FUNC
60 * @tc.require: SR000HRKKA
61 */
62 HWTEST_F(DentryMetaFileTest, MetaFileHandleFileByFd001, TestSize.Level1)
63 {
64 MetaFile mFile(TEST_USER_ID, "/");
65 unsigned long endBlock = 0;
66 uint32_t level = 0;
67 int ret = mFile.HandleFileByFd(endBlock, level);
68 EXPECT_EQ(ret, EINVAL);
69 }
70
71 /**
72 * @tc.name: MetaFileHandleFileByFd002
73 * @tc.desc: Verify the MetaFile::HandleFileByFd function
74 * @tc.type: FUNC
75 * @tc.require: SR000HRKKA
76 */
77 HWTEST_F(DentryMetaFileTest, MetaFileHandleFileByFd002, TestSize.Level1)
78 {
79 uint32_t userId = 100;
80 MetaFile mFile(userId, "/");
81 unsigned long endBlock = 0;
82 uint32_t level = 64;
83 int ret = mFile.HandleFileByFd(endBlock, level);
84 EXPECT_EQ(ret, EINVAL);
85 }
86
87 /**
88 * @tc.name: MetaFileHandleFileByFd003
89 * @tc.desc: Verify the MetaFile::HandleFileByFd function
90 * @tc.type: FUNC
91 * @tc.require: SR000HRKKA
92 */
93 HWTEST_F(DentryMetaFileTest, MetaFileHandleFileByFd003, TestSize.Level1)
94 {
95 uint32_t userId = 100;
96 MetaFile mFile(userId, "/");
97 unsigned long endBlock = 0;
98 uint32_t level = 0;
99 int ret = mFile.HandleFileByFd(endBlock, level);
100 EXPECT_EQ(ret, EINVAL);
101 }
102
103 /**
104 * @tc.name: MetaFileCreate001
105 * @tc.desc: Verify the MetaFile::DoCreate function
106 * @tc.type: FUNC
107 * @tc.require: SR000HRKKA
108 */
109 HWTEST_F(DentryMetaFileTest, MetaFileCreate001, TestSize.Level1)
110 {
111 uint32_t userId = 100;
112 std::string cacheDir =
113 "/data/service/el2/" + std::to_string(userId) + "/hmdfs/cache/cloud_cache/dentry_cache/cloud/";
114 ForceRemoveDirectory(cacheDir);
115
116 MetaFile mFile(userId, "/");
117 MetaBase mBase1("file1", "id1");
118 mBase1.size = TEST_ISIZE;
119 int ret = mFile.DoCreate(mBase1);
120 EXPECT_EQ(ret, EINVAL);
121 MetaBase mBase2("file2", "id2");
122 mBase2.size = TEST_ISIZE;
123 ret = mFile.DoCreate(mBase2);
124 EXPECT_EQ(ret, EINVAL);
125 MetaFile mFile2(userId, "/a/b");
126 MetaBase mBase3("file3", "id3");
127 ret = mFile2.DoCreate(mBase3);
128 }
129
130 /**
131 * @tc.name: MetaFileCreate002
132 * @tc.desc: Verify the MetaFile::DoCreate function
133 * @tc.type: FUNC
134 * @tc.require: SR000HRKKA
135 */
136 HWTEST_F(DentryMetaFileTest, MetaFileCreate002, TestSize.Level1)
137 {
138 MetaFile mFile(TEST_USER_ID, "/");
139 MetaBase mBase1("file1", "id1");
140 int ret = mFile.DoCreate(mBase1);
141 EXPECT_EQ(ret, EINVAL);
142 }
143
144 /**
145 * @tc.name: MetaFileLookup001
146 * @tc.desc: Verify the MetaFile::DoLookup function
147 * @tc.type: FUNC
148 * @tc.require: SR000HRKKA
149 */
150 HWTEST_F(DentryMetaFileTest, MetaFileLookup001, TestSize.Level1)
151 {
152 MetaFile mFile(TEST_USER_ID, "/");
153 MetaBase mBase1("file1");
154 int ret = mFile.DoLookup(mBase1);
155 EXPECT_EQ(ret, EINVAL);
156 }
157
158 /**
159 * @tc.name: MetaFileLookup002
160 * @tc.desc: Verify the MetaFile::DoLookup002 function
161 * @tc.type: FUNC
162 * @tc.require: SR000HRKKA
163 */
164 HWTEST_F(DentryMetaFileTest, MetaFileLookup, TestSize.Level1)
165 {
166 uint32_t userId = 100;
167 MetaFile mFile(userId, "/");
168 MetaBase mBase1("file1");
169 int ret = mFile.DoLookup(mBase1);
170 EXPECT_EQ(ret, EINVAL);
171 EXPECT_EQ(mBase1.size, 0);
172 }
173
174 /**
175 * @tc.name: MetaFileUpdate001
176 * @tc.desc: Verify the MetaFile::DoUpdate function
177 * @tc.type: FUNC
178 * @tc.require: SR000HRKKC
179 */
180 HWTEST_F(DentryMetaFileTest, MetaFileUpdate001, TestSize.Level1)
181 {
182 MetaFile mFile(TEST_USER_ID, "/");
183 MetaBase mBase1("file1", "id11");
184 int ret = mFile.DoUpdate(mBase1);
185 EXPECT_EQ(ret, EINVAL);
186 }
187
188 /**
189 * @tc.name: MetaFileUpdate
190 * @tc.desc: Verify the MetaFile::DoUpdate function
191 * @tc.type: FUNC
192 * @tc.require: SR000HRKKC
193 */
194 HWTEST_F(DentryMetaFileTest, MetaFileUpdate, TestSize.Level1)
195 {
196 uint32_t userId = 100;
197 MetaFile mFile(userId, "/");
198 MetaBase mBase1("file1", "id11");
199 mBase1.size = 0;
200 int ret = mFile.DoUpdate(mBase1);
201 EXPECT_EQ(ret, EINVAL);
202 MetaBase mBase2("file1");
203 ret = mFile.DoLookup(mBase2);
204 EXPECT_EQ(ret, EINVAL);
205 EXPECT_EQ(mBase2.size, 0);
206 }
207
208 /**
209 * @tc.name: MetaFileRename
210 * @tc.desc: Verify the MetaFile::DoRename function
211 * @tc.type: FUNC
212 * @tc.require: SR000HRKKC
213 */
214 HWTEST_F(DentryMetaFileTest, MetaFileRename, TestSize.Level1)
215 {
216 uint32_t userId = 100;
217 MetaFile mFile(userId, "/");
218 MetaBase mBase1("file2");
219 int ret = mFile.DoRename(mBase1, "file4");
220 EXPECT_EQ(ret, EINVAL);
221 MetaBase mBase2("file4");
222 ret = mFile.DoLookup(mBase2);
223 EXPECT_EQ(ret, EINVAL);
224 EXPECT_EQ(mBase2.size, 0);
225 }
226
227 /**
228 * @tc.name: MetaFileRemove001
229 * @tc.desc: Verify the MetaFile::DoRemove function
230 * @tc.type: FUNC
231 * @tc.require: SR000HRKJB
232 */
233 HWTEST_F(DentryMetaFileTest, MetaFileRemove001, TestSize.Level1)
234 {
235 MetaFile mFile(TEST_USER_ID, "/");
236 MetaBase mBase1("file1");
237 int ret = mFile.DoRemove(mBase1);
238 EXPECT_EQ(ret, EINVAL);
239 }
240
241 /**
242 * @tc.name: MetaFileRemove002
243 * @tc.desc: Verify the MetaFile::DoRemove function
244 * @tc.type: FUNC
245 * @tc.require: SR000HRKJB
246 */
247 HWTEST_F(DentryMetaFileTest, MetaFileRemove002, TestSize.Level1)
248 {
249 uint32_t userId = 100;
250 MetaFile mFile(userId, "/");
251 MetaBase mBase1("file1");
252 int ret = mFile.DoRemove(mBase1);
253 EXPECT_EQ(ret, EINVAL);
254 MetaBase mBase2("file1");
255 ret = mFile.DoLookup(mBase2);
256 EXPECT_EQ(ret, EINVAL);
257 }
258
259 /**
260 * @tc.name: LoadChildren001
261 * @tc.desc: Verify the LoadChildren
262 * @tc.type: FUNC
263 * @tc.require: issueI7SP3A
264 */
265 HWTEST_F(DentryMetaFileTest, LoadChildren001, TestSize.Level1)
266 {
267 GTEST_LOG_(INFO) << "LoadChildren001 Start";
268 try {
269 uint32_t userId = 100;
270 MetaFile mFile(userId, "/");
271 std::vector<MetaBase> bases;
272 int ret = mFile.LoadChildren(bases);
273 EXPECT_EQ(ret, EINVAL);
274 } catch (...) {
275 EXPECT_FALSE(false);
276 GTEST_LOG_(INFO) << "LoadChildren001 ERROR";
277 }
278 GTEST_LOG_(INFO) << "LoadChildren001 End";
279 }
280
281 /**
282 * @tc.name: LoadChildren002
283 * @tc.desc: Verify the LoadChildren
284 * @tc.type: FUNC
285 * @tc.require: issueI7SP3A
286 */
287 HWTEST_F(DentryMetaFileTest, LoadChildren002, TestSize.Level1)
288 {
289 GTEST_LOG_(INFO) << "LoadChildren002 Start";
290 try {
291 MetaFile mFile(TEST_USER_ID, "/");
292 std::vector<MetaBase> bases;
293 int ret = mFile.LoadChildren(bases);
294 EXPECT_EQ(ret, EINVAL);
295 } catch (...) {
296 EXPECT_FALSE(false);
297 GTEST_LOG_(INFO) << "LoadChildren002 ERROR";
298 }
299 GTEST_LOG_(INFO) << "LoadChildren002 End";
300 }
301
302 /**
303 * @tc.name: MetaFileMgr001
304 * @tc.desc: Verify the MetaFileMgr
305 * @tc.type: FUNC
306 * @tc.require: SR000HRKJB
307 */
308 HWTEST_F(DentryMetaFileTest, MetaFileMgr001, TestSize.Level1)
309 {
310 GTEST_LOG_(INFO) << "MetaFileMgr001 Start";
311 try {
312 uint32_t userId = 100;
313 auto m = MetaFileMgr::GetInstance().GetMetaFile(userId, "/o/p/q/r/s/t");
314 MetaBase mBase1("file1", "file1");
315 EXPECT_EQ(m->DoCreate(mBase1), EINVAL);
316 m = nullptr;
317 MetaFileMgr::GetInstance().ClearAll();
318 } catch (...) {
319 EXPECT_FALSE(false);
320 GTEST_LOG_(INFO) << " MetaFileMgr001 ERROR";
321 }
322 GTEST_LOG_(INFO) << "MetaFileMgr001 End";
323 }
324
325 /**
326 * @tc.name: MetaFileMgr002
327 * @tc.desc: Verify the MetaFileMgr
328 * @tc.type: FUNC
329 * @tc.require: issueI7SP3A
330 */
331 HWTEST_F(DentryMetaFileTest, MetaFileMgr002, TestSize.Level1)
332 {
333 GTEST_LOG_(INFO) << "MetaFileMgr002 Start";
334 try {
335 uint32_t userId = 100;
336 auto m = MetaFileMgr::GetInstance().GetMetaFile(userId, "/o/p/q/r/s/t");
337 MetaBase mBase1("testLongLongfileName", "testLongLongfileName");
338 EXPECT_EQ(m->DoCreate(mBase1), EINVAL);
339 m = nullptr;
340 MetaFileMgr::GetInstance().ClearAll();
341 } catch (...) {
342 EXPECT_FALSE(false);
343 GTEST_LOG_(INFO) << " MetaFileMgr002 ERROR";
344 }
345 GTEST_LOG_(INFO) << "MetaFileMgr002 End";
346 }
347
348 /**
349 * @tc.name:RecordIdToCloudId001
350 * @tc.desc: Verify the RecordIdToCloudId
351 * @tc.type: FUNC
352 * @tc.require: issueI7SP3A
353 */
354 HWTEST_F(DentryMetaFileTest, RecordIdToCloudId001, TestSize.Level1)
355 {
356 GTEST_LOG_(INFO) << "RecordIdToCloudId001 Start";
357 try {
358 std::string hexStr = "";
359 string ret = MetaFileMgr::GetInstance().RecordIdToCloudId(hexStr);
360 EXPECT_EQ(ret, "");
361 MetaFileMgr::GetInstance().ClearAll();
362 } catch (...) {
363 EXPECT_FALSE(false);
364 GTEST_LOG_(INFO) << "RecordIdToCloudId001 ERROR";
365 }
366 GTEST_LOG_(INFO) << "RecordIdToCloudId001 End";
367 }
368
369 /**
370 * @tc.name:RecordIdToCloudId002
371 * @tc.desc: Verify the RecordIdToCloudId
372 * @tc.type: FUNC
373 * @tc.require: issueI7SP3A
374 */
375 HWTEST_F(DentryMetaFileTest, RecordIdToCloudId002, TestSize.Level1)
376 {
377 GTEST_LOG_(INFO) << "RecordIdToCloudId002 Start";
378 try {
379 std::string hexStr = "test";
380 string ret = MetaFileMgr::GetInstance().RecordIdToCloudId(hexStr);
381 EXPECT_EQ(ret, "");
382 MetaFileMgr::GetInstance().ClearAll();
383 } catch (...) {
384 EXPECT_FALSE(false);
385 GTEST_LOG_(INFO) << "RecordIdToCloudId002 ERROR";
386 }
387 GTEST_LOG_(INFO) << "RecordIdToCloudId002 End";
388 }
389
390 /**
391 * @tc.name: GetParentDir001
392 * @tc.desc: Verify the GetParentDir
393 * @tc.type: FUNC
394 * @tc.require: issueI7SP3A
395 */
396 HWTEST_F(DentryMetaFileTest, GetParentDir001, TestSize.Level1)
397 {
398 GTEST_LOG_(INFO) << "GetParentDir001 Start";
399 try {
400 string str = MetaFile::GetParentDir("");
401 EXPECT_EQ(str, "");
402 str = MetaFile::GetParentDir("/");
403 EXPECT_EQ(str, "");
404 str = MetaFile::GetParentDir("abc");
405 EXPECT_EQ(str, "/");
406 str = MetaFile::GetParentDir("/abc");
407 EXPECT_EQ(str, "/");
408 str = MetaFile::GetParentDir("/abc/def");
409 EXPECT_EQ(str, "/abc");
410 } catch (...) {
411 EXPECT_FALSE(false);
412 GTEST_LOG_(INFO) << " GetParentDir001 ERROR";
413 }
414 GTEST_LOG_(INFO) << "GetParentDir001 End";
415 }
416
417 /**
418 * @tc.name: GetFileName001
419 * @tc.desc: Verify the GetFileName
420 * @tc.type: FUNC
421 * @tc.require: issueI7SP3A
422 */
423 HWTEST_F(DentryMetaFileTest, GetFileName001, TestSize.Level1)
424 {
425 GTEST_LOG_(INFO) << "GetFileName001 Start";
426 try {
427 string str = MetaFile::GetFileName("");
428 EXPECT_EQ(str, "");
429 str = MetaFile::GetFileName("/");
430 EXPECT_EQ(str, "");
431 str = MetaFile::GetFileName("abc");
432 EXPECT_EQ(str, "");
433 str = MetaFile::GetFileName("/abc/def");
434 EXPECT_EQ(str, "def");
435 } catch (...) {
436 EXPECT_FALSE(false);
437 GTEST_LOG_(INFO) << " GetFileName001 ERROR";
438 }
439 GTEST_LOG_(INFO) << "GetFileName001 End";
440 }
441 } // namespace OHOS::FileManagement::CloudSync::Test