1 /*
2 * Copyright (c) 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
16 #include <fstream>
17 #include <filesystem>
18 #include <gtest/gtest.h>
19 #include "listfile_core.h"
20
21 #define DIR_PATH "/data/test/ListFileCoreTest"
22 #define EMPTY_PATH "/data/test/Empty"
23
24 namespace OHOS {
25 namespace FileManagement {
26 namespace ModuleFileIO {
27 using namespace std;
28 namespace fs = std::filesystem;
29
create_file(const fs::path & path,const std::vector<uint8_t> & data,bool binary=true)30 static void create_file(const fs::path& path, const std::vector<uint8_t>& data, bool binary = true)
31 {
32 fs::create_directories(path.parent_path()); // 确保目录存在
33 std::ofstream file(path, binary ? std::ios::binary : std::ios::out);
34 if (!file) {
35 GTEST_LOG_(INFO) << "create_directories failed";
36 return;
37 }
38 file.write(reinterpret_cast<const char*>(data.data()), data.size());
39 GTEST_LOG_(INFO) << "create_directories success";
40 }
41
WriteBuffer(const string filename)42 static void WriteBuffer(const string filename)
43 {
44 const int targetSize = 1024;
45 std::vector<char> buffer(targetSize, 0);
46 std::ofstream file(filename, std::ios::binary);
47 file.write(buffer.data(), buffer.size());
48 }
49
50 class ListFileCoreTest : public testing::Test {
51 public:
SetUpTestCase(void)52 static void SetUpTestCase(void)
53 {
54 fs::create_directory(EMPTY_PATH);
55 const std::vector<fs::path> directories = {
56 "/data/test/ListFileCoreTest", // 单级目录
57 "/data/test/ListFileCoreTest/level1", // 二级目录
58 "/data/test/ListFileCoreTest/level1/level2" // 三级目录
59 };
60
61 // 为每个文件类型创建3个文件
62 for (int i = 0; i < 3; ++i) {
63 create_file(directories[i] / ("text_" + std::to_string(i + 1) + ".txt"),
64 {'F', 'i', 'l', 'e', ' ', char('0' + i + 1)}, false);
65
66 create_file(directories[i] / ("image_" + std::to_string(i + 1) + ".png"),
67 {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A});
68
69 create_file(directories[i] / ("photo_" + std::to_string(i + 1) + ".jpg"),
70 {0xFF, 0xD8, 0xFF, 0xE0, 0x00, 0x10, 0x4A, 0x46});
71
72 create_file(directories[i] / ("data_" + std::to_string(i + 1) + ".data"),
73 {0xAB, 0xCD, 0xEF, char(i), char(i + 1), char(i + 2)});
74 }
75
76 WriteBuffer("/data/test/ListFileCoreTest/text_1.txt");
77 };
TearDownTestCase()78 static void TearDownTestCase()
79 {
80 rmdir(DIR_PATH);
81 rmdir(EMPTY_PATH);
82 };
SetUp()83 void SetUp() {};
TearDown()84 void TearDown() {};
85 };
86
87 /**
88 * @tc.name: DoListFileCoreTest_0001
89 * @tc.desc: Test function of DoListFileCore() interface for error suffix.
90 * @tc.size: MEDIUM
91 * @tc.type: FUNC
92 * @tc.level Level 1
93 */
94 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0001, testing::ext::TestSize.Level1)
95 {
96 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0001";
97 FsListFileOptions opt;
98 FsFileFilter filter;
99 std::vector<std::string> suffixVector = {"txt"};
100 std::optional<std::vector<std::string>> optionalSuffix = suffixVector;
101 filter.SetSuffix(optionalSuffix);
102 opt.filter = filter;
103
104 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
105 EXPECT_FALSE(result.IsSuccess());
106
107 auto err = result.GetError();
108 EXPECT_EQ(err.GetErrNo(), 13900020);
109
110 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0001";
111 }
112
113 /**
114 * @tc.name: DoListFileCoreTest_0002
115 * @tc.desc: Test function of DoListFileCore() interface for error suffix.
116 * @tc.size: MEDIUM
117 * @tc.type: FUNC
118 * @tc.level Level 1
119 */
120 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0002, testing::ext::TestSize.Level1)
121 {
122 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0002";
123 FsListFileOptions opt;
124 FsFileFilter filter;
125 std::vector<std::string> suffixVector = {".tx@t"};
126 std::optional<std::vector<std::string>> optionalSuffix = suffixVector;
127 filter.SetSuffix(optionalSuffix);
128 opt.filter = filter;
129
130 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
131 EXPECT_FALSE(result.IsSuccess());
132
133 auto err = result.GetError();
134 EXPECT_EQ(err.GetErrNo(), 13900020);
135
136 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0002";
137 }
138
139 /**
140 * @tc.name: DoListFileCoreTest_0003
141 * @tc.desc: Test function of DoListFileCore() interface for error listNum.
142 * @tc.size: MEDIUM
143 * @tc.type: FUNC
144 * @tc.level Level 1
145 */
146 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0003, testing::ext::TestSize.Level1)
147 {
148 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0003";
149 FsListFileOptions opt;
150 opt.listNum = -5;
151
152 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
153 EXPECT_FALSE(result.IsSuccess());
154
155 auto err = result.GetError();
156 EXPECT_EQ(err.GetErrNo(), 13900020);
157
158 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0003";
159 }
160
161 /**
162 * @tc.name: DoListFileCoreTest_0004
163 * @tc.desc: Test function of DoListFileCore() interface for current suffix.
164 * @tc.size: MEDIUM
165 * @tc.type: FUNC
166 * @tc.level Level 1
167 */
168 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0004, testing::ext::TestSize.Level1)
169 {
170 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0004";
171 FsListFileOptions opt;
172 FsFileFilter filter;
173 std::vector<std::string> suffixVector = {".txt"};
174 std::optional<std::vector<std::string>> optionalSuffix = suffixVector;
175 filter.SetSuffix(optionalSuffix);
176 opt.filter = filter;
177
178 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
179 ASSERT_TRUE(result.IsSuccess());
180
181 auto files = result.GetData().value();
182 EXPECT_EQ(files.size(), 2);
183 EXPECT_EQ(files[0], "text_1.txt");
184
185 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0004";
186 }
187
188 /**
189 * @tc.name: DoListFileCoreTest_0005
190 * @tc.desc: Test function of DoListFileCore() interface for no maching suffix .
191 * @tc.size: MEDIUM
192 * @tc.type: FUNC
193 * @tc.level Level 1
194 */
195 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0005, testing::ext::TestSize.Level1)
196 {
197 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0005";
198 FsListFileOptions opt;
199 FsFileFilter filter;
200 std::vector<std::string> suffixVector = {".abc"};
201 std::optional<std::vector<std::string>> optionalSuffix = suffixVector;
202 filter.SetSuffix(optionalSuffix);
203 opt.filter = filter;
204
205 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
206 ASSERT_TRUE(result.IsSuccess());
207
208 auto files = result.GetData().value();
209 EXPECT_FALSE(files[0].empty());
210 EXPECT_EQ(files[0], "level1");
211
212 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0005";
213 }
214
215 /**
216 * @tc.name: DoListFileCoreTest_0006
217 * @tc.desc: Test function of DoListFileCore() interface for current display name .
218 * @tc.size: MEDIUM
219 * @tc.type: FUNC
220 * @tc.level Level 1
221 */
222 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0006, testing::ext::TestSize.Level1)
223 {
224 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0006";
225 FsListFileOptions opt;
226 FsFileFilter filter;
227 std::vector<std::string> displayNameVector = {"text*.txt"};
228 std::optional<std::vector<std::string>> optionalDisplayName = displayNameVector;
229 filter.SetDisplayName(optionalDisplayName);
230 opt.filter = filter;
231
232 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
233 ASSERT_TRUE(result.IsSuccess());
234
235 auto files = result.GetData().value();
236 EXPECT_EQ(files.size(), 1);
237 EXPECT_EQ(files[0], "text_1.txt");
238
239 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0006";
240 }
241
242 /**
243 * @tc.name: DoListFileCoreTest_0007
244 * @tc.desc: Test function of DoListFileCore() interface for current fileSizeOver .
245 * @tc.size: MEDIUM
246 * @tc.type: FUNC
247 * @tc.level Level 1
248 */
249 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0007, testing::ext::TestSize.Level1)
250 {
251 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0007";
252 FsListFileOptions opt;
253 FsFileFilter filter;
254 filter.SetFileSizeOver(500);
255 opt.filter = filter;
256
257 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
258 ASSERT_TRUE(result.IsSuccess());
259
260 auto files = result.GetData().value();
261 EXPECT_EQ(files.size(), 2);
262 EXPECT_EQ(files[0], "text_1.txt");
263 EXPECT_EQ(files[1], "level1");
264
265 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0007";
266 }
267
268 /**
269 * @tc.name: DoListFileCoreTest_0008
270 * @tc.desc: Test function of DoListFileCore() interface for displayMame = 0 .
271 * @tc.size: MEDIUM
272 * @tc.type: FUNC
273 * @tc.level Level 1
274 */
275 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0008, testing::ext::TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0008";
278 FsListFileOptions opt;
279 FsFileFilter filter;
280 std::vector<std::string> displayNameVector = {};
281 std::optional<std::vector<std::string>> optionalDisplayName = displayNameVector;
282 filter.SetDisplayName(optionalDisplayName);
283 opt.filter = filter;
284
285 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
286 EXPECT_FALSE(result.IsSuccess());
287
288 auto err = result.GetError();
289 EXPECT_EQ(err.GetErrNo(), 13900020);
290
291 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0008";
292 }
293
294 /**
295 * @tc.name: DoListFileCoreTest_0009
296 * @tc.desc: Test function of DoListFileCore() interface for error fileSizeOver .
297 * @tc.size: MEDIUM
298 * @tc.type: FUNC
299 * @tc.level Level 1
300 */
301 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0009, testing::ext::TestSize.Level1)
302 {
303 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0009";
304 FsListFileOptions opt;
305 FsFileFilter filter;
306 filter.SetFileSizeOver(-1);
307 opt.filter = filter;
308
309 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
310 EXPECT_FALSE(result.IsSuccess());
311
312 auto err = result.GetError();
313 EXPECT_EQ(err.GetErrNo(), 13900020);
314
315 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0009";
316 }
317
318 /**
319 * @tc.name: DoListFileCoreTest_0010
320 * @tc.desc: Test function of DoListFileCore() interface for error lstModitiedAfter .
321 * @tc.size: MEDIUM
322 * @tc.type: FUNC
323 * @tc.level Level 1
324 */
325 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0010, testing::ext::TestSize.Level1)
326 {
327 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0010";
328 FsListFileOptions opt;
329 FsFileFilter filter;
330 filter.SetLastModifiedAfter(-1);
331 opt.filter = filter;
332
333 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
334 EXPECT_FALSE(result.IsSuccess());
335
336 auto err = result.GetError();
337 EXPECT_EQ(err.GetErrNo(), 13900020);
338
339 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0010";
340 }
341
342 /**
343 * @tc.name: DoListFileCoreTest_0011
344 * @tc.desc: Test function of DoListFileCore() interface for true recursion .
345 * @tc.size: MEDIUM
346 * @tc.type: FUNC
347 * @tc.level Level 1
348 */
349 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0011, testing::ext::TestSize.Level1)
350 {
351 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0011";
352 FsListFileOptions opt;
353 opt.recursion = true;
354
355 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
356 ASSERT_TRUE(result.IsSuccess());
357
358 auto files = result.GetData().value();
359 EXPECT_EQ(files.size(), 12);
360 EXPECT_EQ(files[0], "/text_1.txt");
361
362 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0011";
363 }
364
365 /**
366 * @tc.name: DoListFileCoreTest_0012
367 * @tc.desc: Test function of DoListFileCore() interface for empty directory .
368 * @tc.size: MEDIUM
369 * @tc.type: FUNC
370 * @tc.level Level 1
371 */
372 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0012, testing::ext::TestSize.Level1)
373 {
374 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0012";
375 auto result = ListFileCore::DoListFile(EMPTY_PATH);
376 ASSERT_TRUE(result.IsSuccess());
377
378 auto files = result.GetData().value();
379 EXPECT_TRUE(files.empty());
380
381 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0012";
382 }
383
384 /**
385 * @tc.name: DoListFileCoreTest_0013
386 * @tc.desc: Test function of DoListFileCore() interface for current listNum.
387 * @tc.size: MEDIUM
388 * @tc.type: FUNC
389 * @tc.level Level 1
390 */
391 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0013, testing::ext::TestSize.Level1)
392 {
393 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0013";
394 FsListFileOptions opt;
395 opt.listNum = 3;
396
397 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
398 ASSERT_TRUE(result.IsSuccess());
399
400 auto files = result.GetData().value();
401 EXPECT_EQ(files.size(), 3);
402
403 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0013";
404 }
405
406 /**
407 * @tc.name: DoListFileCoreTest_0014
408 * @tc.desc: Test function of DoListFileCore() interface for no such file or directory.
409 * @tc.size: MEDIUM
410 * @tc.type: FUNC
411 * @tc.level Level 1
412 */
413 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0014, testing::ext::TestSize.Level1)
414 {
415 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0014";
416 auto result = ListFileCore::DoListFile("/data/local/tmp/ascecedssw");
417 EXPECT_FALSE(result.IsSuccess());
418
419 auto err = result.GetError();
420 EXPECT_EQ(err.GetErrNo(), 13900002);
421
422 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0014";
423 }
424
425 /**
426 * @tc.name: DoListFileCoreTest_0015
427 * @tc.desc: Test function of DoListFileCore() interface for >256 length suffix.
428 * @tc.size: MEDIUM
429 * @tc.type: FUNC
430 * @tc.level Level 1
431 */
432 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0015, testing::ext::TestSize.Level1)
433 {
434 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0015";
435 FsListFileOptions opt;
436 FsFileFilter filter;
437
438 const size_t targetLength = 257;
439 std::string str = ".";
440 for (size_t i = 1; i < targetLength; ++i) {
441 str += std::to_string(i % 10);
442 }
443
444 std::vector<std::string> suffixVector = {str};
445 std::optional<std::vector<std::string>> optionalSuffix = suffixVector;
446 filter.SetSuffix(optionalSuffix);
447 opt.filter = filter;
448
449 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
450 EXPECT_FALSE(result.IsSuccess());
451
452 auto err = result.GetError();
453 EXPECT_EQ(err.GetErrNo(), 13900020);
454
455 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0015";
456 }
457
458 /**
459 * @tc.name: DoListFileCoreTest_0016
460 * @tc.desc: Test function of DoListFileCore() interface for empty suffix.
461 * @tc.size: MEDIUM
462 * @tc.type: FUNC
463 * @tc.level Level 1
464 */
465 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0016, testing::ext::TestSize.Level1)
466 {
467 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0016";
468 FsListFileOptions opt;
469 FsFileFilter filter;
470 std::vector<std::string> suffixVector = {};
471 std::optional<std::vector<std::string>> optionalSuffix = suffixVector;
472 filter.SetSuffix(optionalSuffix);
473 opt.filter = filter;
474
475 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
476 EXPECT_FALSE(result.IsSuccess());
477
478 auto err = result.GetError();
479 EXPECT_EQ(err.GetErrNo(), 13900020);
480
481 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0016";
482 }
483
484 /**
485 * @tc.name: DoListFileCoreTest_0017
486 * @tc.desc: Test function of DoListFileCore() interface for 0 listNum.
487 * @tc.size: MEDIUM
488 * @tc.type: FUNC
489 * @tc.level Level 1
490 */
491 HWTEST_F(ListFileCoreTest, DoListFileCoreTest_0017, testing::ext::TestSize.Level1)
492 {
493 GTEST_LOG_(INFO) << "ListFileCoreTest-begin DoListFileCoreTest_0017";
494 FsListFileOptions opt;
495 opt.listNum = 0;
496
497 auto result = ListFileCore::DoListFile(DIR_PATH, opt);
498 ASSERT_TRUE(result.IsSuccess());
499
500 auto files = result.GetData().value();
501 EXPECT_EQ(files.size(), 5);
502
503 GTEST_LOG_(INFO) << "ListFileCoreTest-end DoListFileCoreTest_0017";
504 }
505
506 }
507 }
508 }