file_enumerator_unittest.cc 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614
  1. // Copyright 2017 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/files/file_enumerator.h"
  5. #include <string>
  6. #include <utility>
  7. #include <vector>
  8. #include "base/containers/circular_deque.h"
  9. #include "base/files/file_path.h"
  10. #include "base/files/file_util.h"
  11. #include "base/files/scoped_temp_dir.h"
  12. #include "base/logging.h"
  13. #include "build/build_config.h"
  14. #include "testing/gmock/include/gmock/gmock.h"
  15. #include "testing/gtest/include/gtest/gtest.h"
  16. using testing::ElementsAre;
  17. using testing::IsEmpty;
  18. using testing::UnorderedElementsAre;
  19. namespace base {
  20. namespace {
  21. const FilePath::StringType kEmptyPattern;
  22. const std::vector<FileEnumerator::FolderSearchPolicy> kFolderSearchPolicies{
  23. FileEnumerator::FolderSearchPolicy::MATCH_ONLY,
  24. FileEnumerator::FolderSearchPolicy::ALL};
  25. struct TestFile {
  26. TestFile(const FilePath::CharType* file_name, const char* c)
  27. : path(file_name), contents(c) {}
  28. TestFile(const FilePath::CharType* directory,
  29. const FilePath::CharType* file_name,
  30. const char* c)
  31. : path(FilePath(directory).Append(file_name)), contents(c) {}
  32. const FilePath path;
  33. const std::string contents;
  34. File::Info info;
  35. bool found = false;
  36. };
  37. struct TestDirectory {
  38. explicit TestDirectory(const FilePath::CharType* n) : name(n) {}
  39. const FilePath name;
  40. File::Info info;
  41. bool found = false;
  42. };
  43. void CheckModificationTime(const FileEnumerator::FileInfo& actual,
  44. Time expected_last_modified_time) {
  45. #if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
  46. // On POSIX, GetLastModifiedTime() rounds down to the second, but
  47. // File::GetInfo() does not.
  48. Time::Exploded exploded;
  49. expected_last_modified_time.UTCExplode(&exploded);
  50. exploded.millisecond = 0;
  51. EXPECT_TRUE(Time::FromUTCExploded(exploded, &expected_last_modified_time));
  52. #endif
  53. EXPECT_EQ(actual.GetLastModifiedTime(), expected_last_modified_time);
  54. }
  55. void CheckFileAgainstInfo(const FileEnumerator::FileInfo& actual,
  56. TestFile& expected) {
  57. EXPECT_FALSE(expected.found)
  58. << "Got " << expected.path.BaseName().value() << " twice";
  59. expected.found = true;
  60. EXPECT_EQ(actual.GetSize(), int64_t(expected.contents.size()));
  61. CheckModificationTime(actual, expected.info.last_modified);
  62. }
  63. void CheckDirectoryAgainstInfo(const FileEnumerator::FileInfo& actual,
  64. TestDirectory& expected) {
  65. EXPECT_FALSE(expected.found) << "Got " << expected.name.value() << " twice";
  66. expected.found = true;
  67. CheckModificationTime(actual, expected.info.last_modified);
  68. }
  69. circular_deque<FilePath> RunEnumerator(
  70. const FilePath& root_path,
  71. bool recursive,
  72. int file_type,
  73. const FilePath::StringType& pattern,
  74. FileEnumerator::FolderSearchPolicy folder_search_policy) {
  75. circular_deque<FilePath> rv;
  76. FileEnumerator enumerator(root_path, recursive, file_type, pattern,
  77. folder_search_policy,
  78. FileEnumerator::ErrorPolicy::IGNORE_ERRORS);
  79. for (auto file = enumerator.Next(); !file.empty(); file = enumerator.Next())
  80. rv.emplace_back(std::move(file));
  81. return rv;
  82. }
  83. bool CreateDummyFile(const FilePath& path) {
  84. return WriteFile(path, "42", sizeof("42")) == sizeof("42");
  85. }
  86. bool GetFileInfo(const FilePath& file_path, File::Info& info) {
  87. // FLAG_WIN_BACKUP_SEMANTICS: Needed to open directories on Windows.
  88. File f(file_path,
  89. File::FLAG_OPEN | File::FLAG_READ | File::FLAG_WIN_BACKUP_SEMANTICS);
  90. if (!f.IsValid()) {
  91. LOG(ERROR) << "Could not open " << file_path.value() << ": "
  92. << File::ErrorToString(f.error_details());
  93. return false;
  94. }
  95. if (!f.GetInfo(&info)) {
  96. std::string last_error = File::ErrorToString(File::GetLastFileError());
  97. LOG(ERROR) << "Could not get info about " << file_path.value() << ": "
  98. << last_error;
  99. return false;
  100. }
  101. return true;
  102. }
  103. void SetUpTestFiles(const ScopedTempDir& temp_dir,
  104. std::vector<TestFile>& files) {
  105. for (TestFile& file : files) {
  106. const FilePath file_path = temp_dir.GetPath().Append(file.path);
  107. ASSERT_TRUE(WriteFile(file_path, file.contents));
  108. ASSERT_TRUE(GetFileInfo(file_path, file.info));
  109. }
  110. }
  111. } // namespace
  112. TEST(FileEnumerator, NotExistingPath) {
  113. const FilePath path = FilePath::FromUTF8Unsafe("some_not_existing_path");
  114. ASSERT_FALSE(PathExists(path));
  115. for (auto policy : kFolderSearchPolicies) {
  116. const auto files = RunEnumerator(
  117. path, true, FileEnumerator::FILES | FileEnumerator::DIRECTORIES,
  118. FILE_PATH_LITERAL(""), policy);
  119. EXPECT_THAT(files, IsEmpty());
  120. }
  121. }
  122. TEST(FileEnumerator, EmptyFolder) {
  123. ScopedTempDir temp_dir;
  124. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  125. for (auto policy : kFolderSearchPolicies) {
  126. const auto files =
  127. RunEnumerator(temp_dir.GetPath(), true,
  128. FileEnumerator::FILES | FileEnumerator::DIRECTORIES,
  129. kEmptyPattern, policy);
  130. EXPECT_THAT(files, IsEmpty());
  131. }
  132. }
  133. TEST(FileEnumerator, SingleFileInFolderForFileSearch) {
  134. ScopedTempDir temp_dir;
  135. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  136. const FilePath& path = temp_dir.GetPath();
  137. const FilePath file = path.AppendASCII("test.txt");
  138. ASSERT_TRUE(CreateDummyFile(file));
  139. for (auto policy : kFolderSearchPolicies) {
  140. const auto files = RunEnumerator(
  141. temp_dir.GetPath(), true, FileEnumerator::FILES, kEmptyPattern, policy);
  142. EXPECT_THAT(files, ElementsAre(file));
  143. }
  144. }
  145. TEST(FileEnumerator, SingleFileInFolderForDirSearch) {
  146. ScopedTempDir temp_dir;
  147. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  148. const FilePath& path = temp_dir.GetPath();
  149. ASSERT_TRUE(CreateDummyFile(path.AppendASCII("test.txt")));
  150. for (auto policy : kFolderSearchPolicies) {
  151. const auto files = RunEnumerator(path, true, FileEnumerator::DIRECTORIES,
  152. kEmptyPattern, policy);
  153. EXPECT_THAT(files, IsEmpty());
  154. }
  155. }
  156. TEST(FileEnumerator, SingleFileInFolderWithFiltering) {
  157. ScopedTempDir temp_dir;
  158. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  159. const FilePath& path = temp_dir.GetPath();
  160. const FilePath file = path.AppendASCII("test.txt");
  161. ASSERT_TRUE(CreateDummyFile(file));
  162. for (auto policy : kFolderSearchPolicies) {
  163. auto files = RunEnumerator(path, true, FileEnumerator::FILES,
  164. FILE_PATH_LITERAL("*.txt"), policy);
  165. EXPECT_THAT(files, ElementsAre(file));
  166. files = RunEnumerator(path, true, FileEnumerator::FILES,
  167. FILE_PATH_LITERAL("*.pdf"), policy);
  168. EXPECT_THAT(files, IsEmpty());
  169. }
  170. }
  171. TEST(FileEnumerator, TwoFilesInFolder) {
  172. ScopedTempDir temp_dir;
  173. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  174. const FilePath& path = temp_dir.GetPath();
  175. const FilePath foo_txt = path.AppendASCII("foo.txt");
  176. const FilePath bar_txt = path.AppendASCII("bar.txt");
  177. ASSERT_TRUE(CreateDummyFile(foo_txt));
  178. ASSERT_TRUE(CreateDummyFile(bar_txt));
  179. for (auto policy : kFolderSearchPolicies) {
  180. auto files = RunEnumerator(path, true, FileEnumerator::FILES,
  181. FILE_PATH_LITERAL("*.txt"), policy);
  182. EXPECT_THAT(files, UnorderedElementsAre(foo_txt, bar_txt));
  183. files = RunEnumerator(path, true, FileEnumerator::FILES,
  184. FILE_PATH_LITERAL("foo*"), policy);
  185. EXPECT_THAT(files, ElementsAre(foo_txt));
  186. files = RunEnumerator(path, true, FileEnumerator::FILES,
  187. FILE_PATH_LITERAL("*.pdf"), policy);
  188. EXPECT_THAT(files, IsEmpty());
  189. files =
  190. RunEnumerator(path, true, FileEnumerator::FILES, kEmptyPattern, policy);
  191. EXPECT_THAT(files, UnorderedElementsAre(foo_txt, bar_txt));
  192. }
  193. }
  194. TEST(FileEnumerator, SingleFolderInFolderForFileSearch) {
  195. ScopedTempDir temp_dir;
  196. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  197. const FilePath& path = temp_dir.GetPath();
  198. ScopedTempDir temp_subdir;
  199. ASSERT_TRUE(temp_subdir.CreateUniqueTempDirUnderPath(path));
  200. for (auto policy : kFolderSearchPolicies) {
  201. const auto files =
  202. RunEnumerator(path, true, FileEnumerator::FILES, kEmptyPattern, policy);
  203. EXPECT_THAT(files, IsEmpty());
  204. }
  205. }
  206. TEST(FileEnumerator, SingleFolderInFolderForDirSearch) {
  207. ScopedTempDir temp_dir;
  208. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  209. const FilePath& path = temp_dir.GetPath();
  210. ScopedTempDir temp_subdir;
  211. ASSERT_TRUE(temp_subdir.CreateUniqueTempDirUnderPath(path));
  212. for (auto policy : kFolderSearchPolicies) {
  213. const auto files = RunEnumerator(path, true, FileEnumerator::DIRECTORIES,
  214. kEmptyPattern, policy);
  215. EXPECT_THAT(files, ElementsAre(temp_subdir.GetPath()));
  216. }
  217. }
  218. TEST(FileEnumerator, TwoFoldersInFolder) {
  219. ScopedTempDir temp_dir;
  220. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  221. const FilePath& path = temp_dir.GetPath();
  222. const FilePath subdir_foo = path.AppendASCII("foo");
  223. const FilePath subdir_bar = path.AppendASCII("bar");
  224. ASSERT_TRUE(CreateDirectory(subdir_foo));
  225. ASSERT_TRUE(CreateDirectory(subdir_bar));
  226. for (auto policy : kFolderSearchPolicies) {
  227. auto files = RunEnumerator(path, true, FileEnumerator::DIRECTORIES,
  228. kEmptyPattern, policy);
  229. EXPECT_THAT(files, UnorderedElementsAre(subdir_foo, subdir_bar));
  230. files = RunEnumerator(path, true, FileEnumerator::DIRECTORIES,
  231. FILE_PATH_LITERAL("foo"), policy);
  232. EXPECT_THAT(files, ElementsAre(subdir_foo));
  233. }
  234. }
  235. TEST(FileEnumerator, FolderAndFileInFolder) {
  236. ScopedTempDir temp_dir;
  237. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  238. const FilePath& path = temp_dir.GetPath();
  239. ScopedTempDir temp_subdir;
  240. ASSERT_TRUE(temp_subdir.CreateUniqueTempDirUnderPath(path));
  241. const FilePath file = path.AppendASCII("test.txt");
  242. ASSERT_TRUE(CreateDummyFile(file));
  243. for (auto policy : kFolderSearchPolicies) {
  244. auto files =
  245. RunEnumerator(path, true, FileEnumerator::FILES, kEmptyPattern, policy);
  246. EXPECT_THAT(files, ElementsAre(file));
  247. files = RunEnumerator(path, true, FileEnumerator::DIRECTORIES,
  248. kEmptyPattern, policy);
  249. EXPECT_THAT(files, ElementsAre(temp_subdir.GetPath()));
  250. files = RunEnumerator(path, true,
  251. FileEnumerator::FILES | FileEnumerator::DIRECTORIES,
  252. kEmptyPattern, policy);
  253. EXPECT_THAT(files, UnorderedElementsAre(file, temp_subdir.GetPath()));
  254. }
  255. }
  256. TEST(FileEnumerator, FilesInParentFolderAlwaysFirst) {
  257. ScopedTempDir temp_dir;
  258. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  259. const FilePath& path = temp_dir.GetPath();
  260. ScopedTempDir temp_subdir;
  261. ASSERT_TRUE(temp_subdir.CreateUniqueTempDirUnderPath(path));
  262. const FilePath foo_txt = path.AppendASCII("foo.txt");
  263. const FilePath bar_txt = temp_subdir.GetPath().AppendASCII("bar.txt");
  264. ASSERT_TRUE(CreateDummyFile(foo_txt));
  265. ASSERT_TRUE(CreateDummyFile(bar_txt));
  266. for (auto policy : kFolderSearchPolicies) {
  267. const auto files =
  268. RunEnumerator(path, true, FileEnumerator::FILES, kEmptyPattern, policy);
  269. EXPECT_THAT(files, ElementsAre(foo_txt, bar_txt));
  270. }
  271. }
  272. TEST(FileEnumerator, FileInSubfolder) {
  273. ScopedTempDir temp_dir;
  274. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  275. const FilePath subdir = temp_dir.GetPath().AppendASCII("subdir");
  276. ASSERT_TRUE(CreateDirectory(subdir));
  277. const FilePath file = subdir.AppendASCII("test.txt");
  278. ASSERT_TRUE(CreateDummyFile(file));
  279. for (auto policy : kFolderSearchPolicies) {
  280. auto files = RunEnumerator(temp_dir.GetPath(), true, FileEnumerator::FILES,
  281. kEmptyPattern, policy);
  282. EXPECT_THAT(files, ElementsAre(file));
  283. files = RunEnumerator(temp_dir.GetPath(), false, FileEnumerator::FILES,
  284. kEmptyPattern, policy);
  285. EXPECT_THAT(files, IsEmpty());
  286. }
  287. }
  288. TEST(FileEnumerator, FilesInSubfoldersWithFiltering) {
  289. ScopedTempDir temp_dir;
  290. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  291. const FilePath test_txt = temp_dir.GetPath().AppendASCII("test.txt");
  292. const FilePath subdir_foo = temp_dir.GetPath().AppendASCII("foo_subdir");
  293. const FilePath subdir_bar = temp_dir.GetPath().AppendASCII("bar_subdir");
  294. const FilePath foo_test = subdir_foo.AppendASCII("test.txt");
  295. const FilePath foo_foo = subdir_foo.AppendASCII("foo.txt");
  296. const FilePath foo_bar = subdir_foo.AppendASCII("bar.txt");
  297. const FilePath bar_test = subdir_bar.AppendASCII("test.txt");
  298. const FilePath bar_foo = subdir_bar.AppendASCII("foo.txt");
  299. const FilePath bar_bar = subdir_bar.AppendASCII("bar.txt");
  300. ASSERT_TRUE(CreateDummyFile(test_txt));
  301. ASSERT_TRUE(CreateDirectory(subdir_foo));
  302. ASSERT_TRUE(CreateDirectory(subdir_bar));
  303. ASSERT_TRUE(CreateDummyFile(foo_test));
  304. ASSERT_TRUE(CreateDummyFile(foo_foo));
  305. ASSERT_TRUE(CreateDummyFile(foo_bar));
  306. ASSERT_TRUE(CreateDummyFile(bar_test));
  307. ASSERT_TRUE(CreateDummyFile(bar_foo));
  308. ASSERT_TRUE(CreateDummyFile(bar_bar));
  309. auto files =
  310. RunEnumerator(temp_dir.GetPath(), true,
  311. FileEnumerator::FILES | FileEnumerator::DIRECTORIES,
  312. FILE_PATH_LITERAL("foo*"),
  313. FileEnumerator::FolderSearchPolicy::MATCH_ONLY);
  314. EXPECT_THAT(files,
  315. UnorderedElementsAre(subdir_foo, foo_test, foo_foo, foo_bar));
  316. files = RunEnumerator(temp_dir.GetPath(), true,
  317. FileEnumerator::FILES | FileEnumerator::DIRECTORIES,
  318. FILE_PATH_LITERAL("foo*"),
  319. FileEnumerator::FolderSearchPolicy::ALL);
  320. EXPECT_THAT(files, UnorderedElementsAre(subdir_foo, foo_foo, bar_foo));
  321. }
  322. TEST(FileEnumerator, InvalidDirectory) {
  323. ScopedTempDir temp_dir;
  324. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  325. const FilePath test_file = temp_dir.GetPath().AppendASCII("test_file");
  326. ASSERT_TRUE(CreateDummyFile(test_file));
  327. // Attempt to enumerate entries at a regular file path.
  328. FileEnumerator enumerator(test_file, /*recursive=*/true,
  329. FileEnumerator::FILES, kEmptyPattern,
  330. FileEnumerator::FolderSearchPolicy::ALL,
  331. FileEnumerator::ErrorPolicy::STOP_ENUMERATION);
  332. FilePath path = enumerator.Next();
  333. EXPECT_TRUE(path.empty());
  334. // Slightly different outcomes between Windows and POSIX.
  335. #if BUILDFLAG(IS_WIN)
  336. EXPECT_EQ(File::Error::FILE_ERROR_FAILED, enumerator.GetError());
  337. #else
  338. EXPECT_EQ(File::Error::FILE_ERROR_NOT_A_DIRECTORY, enumerator.GetError());
  339. #endif
  340. }
  341. #if BUILDFLAG(IS_POSIX)
  342. TEST(FileEnumerator, SymLinkLoops) {
  343. ScopedTempDir temp_dir;
  344. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  345. const FilePath subdir = temp_dir.GetPath().AppendASCII("subdir");
  346. ASSERT_TRUE(CreateDirectory(subdir));
  347. const FilePath file = subdir.AppendASCII("test.txt");
  348. ASSERT_TRUE(CreateDummyFile(file));
  349. const FilePath link = subdir.AppendASCII("link");
  350. ASSERT_TRUE(CreateSymbolicLink(temp_dir.GetPath(), link));
  351. auto files = RunEnumerator(
  352. temp_dir.GetPath(), true,
  353. FileEnumerator::FILES | FileEnumerator::DIRECTORIES, kEmptyPattern,
  354. FileEnumerator::FolderSearchPolicy::MATCH_ONLY);
  355. EXPECT_THAT(files, UnorderedElementsAre(subdir, link, file));
  356. files = RunEnumerator(subdir, true,
  357. FileEnumerator::FILES | FileEnumerator::DIRECTORIES |
  358. FileEnumerator::SHOW_SYM_LINKS,
  359. kEmptyPattern,
  360. FileEnumerator::FolderSearchPolicy::MATCH_ONLY);
  361. EXPECT_THAT(files, UnorderedElementsAre(link, file));
  362. }
  363. #endif
  364. // Test FileEnumerator::GetInfo() on some files and ensure all the returned
  365. // information is correct.
  366. TEST(FileEnumerator, GetInfo) {
  367. ScopedTempDir temp_dir;
  368. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  369. std::vector<TestFile> files = {
  370. TestFile(FILE_PATH_LITERAL("file1"), "First"),
  371. TestFile(FILE_PATH_LITERAL("file2"), "Second"),
  372. TestFile(FILE_PATH_LITERAL("file3"), "Third-third-third")};
  373. SetUpTestFiles(temp_dir, files);
  374. FileEnumerator file_enumerator(temp_dir.GetPath(), false,
  375. FileEnumerator::FILES);
  376. while (!file_enumerator.Next().empty()) {
  377. auto info = file_enumerator.GetInfo();
  378. bool found = false;
  379. for (TestFile& file : files) {
  380. if (info.GetName() == file.path.BaseName()) {
  381. CheckFileAgainstInfo(info, file);
  382. found = true;
  383. break;
  384. }
  385. }
  386. EXPECT_TRUE(found) << "Got unexpected result " << info.GetName().value();
  387. }
  388. for (const TestFile& file : files) {
  389. EXPECT_TRUE(file.found)
  390. << "File " << file.path.value() << " was not returned";
  391. }
  392. }
  393. // Test that FileEnumerator::GetInfo() works when searching recursively. It also
  394. // tests that it returns the correct information about directories.
  395. TEST(FileEnumerator, GetInfoRecursive) {
  396. ScopedTempDir temp_dir;
  397. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  398. TestDirectory directories[] = {TestDirectory(FILE_PATH_LITERAL("dir1")),
  399. TestDirectory(FILE_PATH_LITERAL("dir2")),
  400. TestDirectory(FILE_PATH_LITERAL("dir3")),
  401. TestDirectory(FILE_PATH_LITERAL("dirempty"))};
  402. for (const TestDirectory& dir : directories) {
  403. const FilePath dir_path = temp_dir.GetPath().Append(dir.name);
  404. ASSERT_TRUE(CreateDirectory(dir_path));
  405. }
  406. std::vector<TestFile> files = {
  407. TestFile(FILE_PATH_LITERAL("dir1"), FILE_PATH_LITERAL("file1"), "First"),
  408. TestFile(FILE_PATH_LITERAL("dir1"), FILE_PATH_LITERAL("file2"), "Second"),
  409. TestFile(FILE_PATH_LITERAL("dir2"), FILE_PATH_LITERAL("fileA"),
  410. "Third-third-3"),
  411. TestFile(FILE_PATH_LITERAL("dir3"), FILE_PATH_LITERAL(".file"), "Dot")};
  412. SetUpTestFiles(temp_dir, files);
  413. // Get last-modification times for directories. Must be done after we create
  414. // all the files.
  415. for (TestDirectory& dir : directories) {
  416. const FilePath dir_path = temp_dir.GetPath().Append(dir.name);
  417. ASSERT_TRUE(GetFileInfo(dir_path, dir.info));
  418. }
  419. FileEnumerator file_enumerator(
  420. temp_dir.GetPath(), true,
  421. FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
  422. while (!file_enumerator.Next().empty()) {
  423. auto info = file_enumerator.GetInfo();
  424. bool found = false;
  425. if (info.IsDirectory()) {
  426. for (TestDirectory& dir : directories) {
  427. if (info.GetName() == dir.name) {
  428. CheckDirectoryAgainstInfo(info, dir);
  429. found = true;
  430. break;
  431. }
  432. }
  433. } else {
  434. for (TestFile& file : files) {
  435. if (info.GetName() == file.path.BaseName()) {
  436. CheckFileAgainstInfo(info, file);
  437. found = true;
  438. break;
  439. }
  440. }
  441. }
  442. EXPECT_TRUE(found) << "Got unexpected result " << info.GetName().value();
  443. }
  444. for (const TestDirectory& dir : directories) {
  445. EXPECT_TRUE(dir.found) << "Directory " << dir.name.value()
  446. << " was not returned";
  447. }
  448. for (const TestFile& file : files) {
  449. EXPECT_TRUE(file.found)
  450. << "File " << file.path.value() << " was not returned";
  451. }
  452. }
  453. #if BUILDFLAG(IS_FUCHSIA)
  454. // FileEnumerator::GetInfo does not work correctly with INCLUDE_DOT_DOT.
  455. // https://crbug.com/1106172
  456. #elif BUILDFLAG(IS_WIN)
  457. // Windows has a bug in their handling of ".."; they always report the file
  458. // modification time of the current directory, not the parent directory. This is
  459. // a bug in Windows, not us -- you can see it with the "dir" command (notice
  460. // that the time of . and .. always match). Skip this test.
  461. // https://crbug.com/1119546
  462. #else
  463. // Tests that FileEnumerator::GetInfo() returns the correct info for the ..
  464. // directory.
  465. TEST(FileEnumerator, GetInfoDotDot) {
  466. ScopedTempDir temp_dir;
  467. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  468. const FilePath::CharType kSubdir[] = FILE_PATH_LITERAL("subdir");
  469. const FilePath subdir_path = temp_dir.GetPath().Append(kSubdir);
  470. ASSERT_TRUE(CreateDirectory(subdir_path));
  471. std::vector<TestFile> files = {
  472. TestFile(kSubdir, FILE_PATH_LITERAL("file1"), "First"),
  473. TestFile(kSubdir, FILE_PATH_LITERAL("file2"), "Second"),
  474. TestFile(kSubdir, FILE_PATH_LITERAL("file3"), "Third-third-third")};
  475. SetUpTestFiles(temp_dir, files);
  476. TestDirectory dotdot(FILE_PATH_LITERAL(".."));
  477. // test_dir/subdir/.. is just test_dir.
  478. ASSERT_TRUE(GetFileInfo(temp_dir.GetPath(), dotdot.info));
  479. FileEnumerator file_enumerator(subdir_path, false,
  480. FileEnumerator::FILES |
  481. FileEnumerator::DIRECTORIES |
  482. FileEnumerator::INCLUDE_DOT_DOT);
  483. while (!file_enumerator.Next().empty()) {
  484. auto info = file_enumerator.GetInfo();
  485. bool found = false;
  486. if (info.IsDirectory()) {
  487. EXPECT_EQ(info.GetName(), FilePath(FILE_PATH_LITERAL("..")));
  488. CheckDirectoryAgainstInfo(info, dotdot);
  489. found = true;
  490. } else {
  491. for (TestFile& file : files) {
  492. if (info.GetName() == file.path.BaseName()) {
  493. CheckFileAgainstInfo(info, file);
  494. found = true;
  495. break;
  496. }
  497. }
  498. }
  499. EXPECT_TRUE(found) << "Got unexpected result " << info.GetName().value();
  500. }
  501. EXPECT_TRUE(dotdot.found) << "Directory .. was not returned";
  502. for (const TestFile& file : files) {
  503. EXPECT_TRUE(file.found)
  504. << "File " << file.path.value() << " was not returned";
  505. }
  506. }
  507. #endif // !BUILDFLAG(IS_FUCHSIA) && !BUILDFLAG(IS_WIN)
  508. } // namespace base