1//===- llvm/unittest/Support/Path.cpp - Path tests ------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/Support/Path.h"
11#include "llvm/Support/Errc.h"
12#include "llvm/Support/ErrorHandling.h"
13#include "llvm/Support/FileSystem.h"
14#include "llvm/Support/MemoryBuffer.h"
15#include "llvm/Support/raw_ostream.h"
16#include "gtest/gtest.h"
17
18#ifdef LLVM_ON_WIN32
19#include <Windows.h>
20#include <winerror.h>
21#endif
22
23using namespace llvm;
24using namespace llvm::sys;
25
26#define ASSERT_NO_ERROR(x)                                                     \
27  if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
28    SmallString<128> MessageStorage;                                           \
29    raw_svector_ostream Message(MessageStorage);                               \
30    Message << #x ": did not return errc::success.\n"                          \
31            << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
32            << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
33    GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
34  } else {                                                                     \
35  }
36
37namespace {
38
39TEST(is_separator, Works) {
40  EXPECT_TRUE(path::is_separator('/'));
41  EXPECT_FALSE(path::is_separator('\0'));
42  EXPECT_FALSE(path::is_separator('-'));
43  EXPECT_FALSE(path::is_separator(' '));
44
45#ifdef LLVM_ON_WIN32
46  EXPECT_TRUE(path::is_separator('\\'));
47#else
48  EXPECT_FALSE(path::is_separator('\\'));
49#endif
50}
51
52TEST(Support, Path) {
53  SmallVector<StringRef, 40> paths;
54  paths.push_back("");
55  paths.push_back(".");
56  paths.push_back("..");
57  paths.push_back("foo");
58  paths.push_back("/");
59  paths.push_back("/foo");
60  paths.push_back("foo/");
61  paths.push_back("/foo/");
62  paths.push_back("foo/bar");
63  paths.push_back("/foo/bar");
64  paths.push_back("//net");
65  paths.push_back("//net/foo");
66  paths.push_back("///foo///");
67  paths.push_back("///foo///bar");
68  paths.push_back("/.");
69  paths.push_back("./");
70  paths.push_back("/..");
71  paths.push_back("../");
72  paths.push_back("foo/.");
73  paths.push_back("foo/..");
74  paths.push_back("foo/./");
75  paths.push_back("foo/./bar");
76  paths.push_back("foo/..");
77  paths.push_back("foo/../");
78  paths.push_back("foo/../bar");
79  paths.push_back("c:");
80  paths.push_back("c:/");
81  paths.push_back("c:foo");
82  paths.push_back("c:/foo");
83  paths.push_back("c:foo/");
84  paths.push_back("c:/foo/");
85  paths.push_back("c:/foo/bar");
86  paths.push_back("prn:");
87  paths.push_back("c:\\");
88  paths.push_back("c:foo");
89  paths.push_back("c:\\foo");
90  paths.push_back("c:foo\\");
91  paths.push_back("c:\\foo\\");
92  paths.push_back("c:\\foo/");
93  paths.push_back("c:/foo\\bar");
94
95  SmallVector<StringRef, 5> ComponentStack;
96  for (SmallVector<StringRef, 40>::const_iterator i = paths.begin(),
97                                                  e = paths.end();
98                                                  i != e;
99                                                  ++i) {
100    for (sys::path::const_iterator ci = sys::path::begin(*i),
101                                   ce = sys::path::end(*i);
102                                   ci != ce;
103                                   ++ci) {
104      ASSERT_FALSE(ci->empty());
105      ComponentStack.push_back(*ci);
106    }
107
108    for (sys::path::reverse_iterator ci = sys::path::rbegin(*i),
109                                     ce = sys::path::rend(*i);
110                                     ci != ce;
111                                     ++ci) {
112      ASSERT_TRUE(*ci == ComponentStack.back());
113      ComponentStack.pop_back();
114    }
115    ASSERT_TRUE(ComponentStack.empty());
116
117    path::has_root_path(*i);
118    path::root_path(*i);
119    path::has_root_name(*i);
120    path::root_name(*i);
121    path::has_root_directory(*i);
122    path::root_directory(*i);
123    path::has_parent_path(*i);
124    path::parent_path(*i);
125    path::has_filename(*i);
126    path::filename(*i);
127    path::has_stem(*i);
128    path::stem(*i);
129    path::has_extension(*i);
130    path::extension(*i);
131    path::is_absolute(*i);
132    path::is_relative(*i);
133
134    SmallString<128> temp_store;
135    temp_store = *i;
136    ASSERT_NO_ERROR(fs::make_absolute(temp_store));
137    temp_store = *i;
138    path::remove_filename(temp_store);
139
140    temp_store = *i;
141    path::replace_extension(temp_store, "ext");
142    StringRef filename(temp_store.begin(), temp_store.size()), stem, ext;
143    stem = path::stem(filename);
144    ext  = path::extension(filename);
145    EXPECT_EQ(*sys::path::rbegin(filename), (stem + ext).str());
146
147    path::native(*i, temp_store);
148  }
149}
150
151TEST(Support, RelativePathIterator) {
152  SmallString<64> Path(StringRef("c/d/e/foo.txt"));
153  typedef SmallVector<StringRef, 4> PathComponents;
154  PathComponents ExpectedPathComponents;
155  PathComponents ActualPathComponents;
156
157  StringRef(Path).split(ExpectedPathComponents, "/");
158
159  for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
160       ++I) {
161    ActualPathComponents.push_back(*I);
162  }
163
164  ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
165
166  for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
167    EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
168  }
169}
170
171TEST(Support, RelativePathDotIterator) {
172  SmallString<64> Path(StringRef(".c/.d/../."));
173  typedef SmallVector<StringRef, 4> PathComponents;
174  PathComponents ExpectedPathComponents;
175  PathComponents ActualPathComponents;
176
177  StringRef(Path).split(ExpectedPathComponents, "/");
178
179  for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
180       ++I) {
181    ActualPathComponents.push_back(*I);
182  }
183
184  ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
185
186  for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
187    EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
188  }
189}
190
191TEST(Support, AbsolutePathIterator) {
192  SmallString<64> Path(StringRef("/c/d/e/foo.txt"));
193  typedef SmallVector<StringRef, 4> PathComponents;
194  PathComponents ExpectedPathComponents;
195  PathComponents ActualPathComponents;
196
197  StringRef(Path).split(ExpectedPathComponents, "/");
198
199  // The root path will also be a component when iterating
200  ExpectedPathComponents[0] = "/";
201
202  for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
203       ++I) {
204    ActualPathComponents.push_back(*I);
205  }
206
207  ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
208
209  for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
210    EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
211  }
212}
213
214TEST(Support, AbsolutePathDotIterator) {
215  SmallString<64> Path(StringRef("/.c/.d/../."));
216  typedef SmallVector<StringRef, 4> PathComponents;
217  PathComponents ExpectedPathComponents;
218  PathComponents ActualPathComponents;
219
220  StringRef(Path).split(ExpectedPathComponents, "/");
221
222  // The root path will also be a component when iterating
223  ExpectedPathComponents[0] = "/";
224
225  for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
226       ++I) {
227    ActualPathComponents.push_back(*I);
228  }
229
230  ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
231
232  for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
233    EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
234  }
235}
236
237#ifdef LLVM_ON_WIN32
238TEST(Support, AbsolutePathIteratorWin32) {
239  SmallString<64> Path(StringRef("c:\\c\\e\\foo.txt"));
240  typedef SmallVector<StringRef, 4> PathComponents;
241  PathComponents ExpectedPathComponents;
242  PathComponents ActualPathComponents;
243
244  StringRef(Path).split(ExpectedPathComponents, "\\");
245
246  // The root path (which comes after the drive name) will also be a component
247  // when iterating.
248  ExpectedPathComponents.insert(ExpectedPathComponents.begin()+1, "\\");
249
250  for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
251       ++I) {
252    ActualPathComponents.push_back(*I);
253  }
254
255  ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
256
257  for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
258    EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
259  }
260}
261#endif // LLVM_ON_WIN32
262
263TEST(Support, AbsolutePathIteratorEnd) {
264  // Trailing slashes are converted to '.' unless they are part of the root path.
265  SmallVector<StringRef, 4> Paths;
266  Paths.push_back("/foo/");
267  Paths.push_back("/foo//");
268  Paths.push_back("//net//");
269#ifdef LLVM_ON_WIN32
270  Paths.push_back("c:\\\\");
271#endif
272
273  for (StringRef Path : Paths) {
274    StringRef LastComponent = *path::rbegin(Path);
275    EXPECT_EQ(".", LastComponent);
276  }
277
278  SmallVector<StringRef, 3> RootPaths;
279  RootPaths.push_back("/");
280  RootPaths.push_back("//net/");
281#ifdef LLVM_ON_WIN32
282  RootPaths.push_back("c:\\");
283#endif
284
285  for (StringRef Path : RootPaths) {
286    StringRef LastComponent = *path::rbegin(Path);
287    EXPECT_EQ(1u, LastComponent.size());
288    EXPECT_TRUE(path::is_separator(LastComponent[0]));
289  }
290}
291
292TEST(Support, HomeDirectory) {
293#ifdef LLVM_ON_UNIX
294  // This test only makes sense on Unix if $HOME is set.
295  if (::getenv("HOME")) {
296#endif
297    SmallString<128> HomeDir;
298    EXPECT_TRUE(path::home_directory(HomeDir));
299    EXPECT_FALSE(HomeDir.empty());
300#ifdef LLVM_ON_UNIX
301  }
302#endif
303}
304
305class FileSystemTest : public testing::Test {
306protected:
307  /// Unique temporary directory in which all created filesystem entities must
308  /// be placed. It is removed at the end of each test (must be empty).
309  SmallString<128> TestDirectory;
310
311  void SetUp() override {
312    ASSERT_NO_ERROR(
313        fs::createUniqueDirectory("file-system-test", TestDirectory));
314    // We don't care about this specific file.
315    errs() << "Test Directory: " << TestDirectory << '\n';
316    errs().flush();
317  }
318
319  void TearDown() override { ASSERT_NO_ERROR(fs::remove(TestDirectory.str())); }
320};
321
322TEST_F(FileSystemTest, Unique) {
323  // Create a temp file.
324  int FileDescriptor;
325  SmallString<64> TempPath;
326  ASSERT_NO_ERROR(
327      fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));
328
329  // The same file should return an identical unique id.
330  fs::UniqueID F1, F2;
331  ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), F1));
332  ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), F2));
333  ASSERT_EQ(F1, F2);
334
335  // Different files should return different unique ids.
336  int FileDescriptor2;
337  SmallString<64> TempPath2;
338  ASSERT_NO_ERROR(
339      fs::createTemporaryFile("prefix", "temp", FileDescriptor2, TempPath2));
340
341  fs::UniqueID D;
342  ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath2), D));
343  ASSERT_NE(D, F1);
344  ::close(FileDescriptor2);
345
346  ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));
347
348  // Two paths representing the same file on disk should still provide the
349  // same unique id.  We can test this by making a hard link.
350  ASSERT_NO_ERROR(fs::create_link(Twine(TempPath), Twine(TempPath2)));
351  fs::UniqueID D2;
352  ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath2), D2));
353  ASSERT_EQ(D2, F1);
354
355  ::close(FileDescriptor);
356
357  SmallString<128> Dir1;
358  ASSERT_NO_ERROR(
359     fs::createUniqueDirectory("dir1", Dir1));
360  ASSERT_NO_ERROR(fs::getUniqueID(Dir1.c_str(), F1));
361  ASSERT_NO_ERROR(fs::getUniqueID(Dir1.c_str(), F2));
362  ASSERT_EQ(F1, F2);
363
364  SmallString<128> Dir2;
365  ASSERT_NO_ERROR(
366     fs::createUniqueDirectory("dir2", Dir2));
367  ASSERT_NO_ERROR(fs::getUniqueID(Dir2.c_str(), F2));
368  ASSERT_NE(F1, F2);
369}
370
371TEST_F(FileSystemTest, TempFiles) {
372  // Create a temp file.
373  int FileDescriptor;
374  SmallString<64> TempPath;
375  ASSERT_NO_ERROR(
376      fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));
377
378  // Make sure it exists.
379  ASSERT_TRUE(sys::fs::exists(Twine(TempPath)));
380
381  // Create another temp tile.
382  int FD2;
383  SmallString<64> TempPath2;
384  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD2, TempPath2));
385  ASSERT_TRUE(TempPath2.endswith(".temp"));
386  ASSERT_NE(TempPath.str(), TempPath2.str());
387
388  fs::file_status A, B;
389  ASSERT_NO_ERROR(fs::status(Twine(TempPath), A));
390  ASSERT_NO_ERROR(fs::status(Twine(TempPath2), B));
391  EXPECT_FALSE(fs::equivalent(A, B));
392
393  ::close(FD2);
394
395  // Remove Temp2.
396  ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));
397  ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));
398  ASSERT_EQ(fs::remove(Twine(TempPath2), false),
399            errc::no_such_file_or_directory);
400
401  std::error_code EC = fs::status(TempPath2.c_str(), B);
402  EXPECT_EQ(EC, errc::no_such_file_or_directory);
403  EXPECT_EQ(B.type(), fs::file_type::file_not_found);
404
405  // Make sure Temp2 doesn't exist.
406  ASSERT_EQ(fs::access(Twine(TempPath2), sys::fs::AccessMode::Exist),
407            errc::no_such_file_or_directory);
408
409  SmallString<64> TempPath3;
410  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "", TempPath3));
411  ASSERT_FALSE(TempPath3.endswith("."));
412
413  // Create a hard link to Temp1.
414  ASSERT_NO_ERROR(fs::create_link(Twine(TempPath), Twine(TempPath2)));
415  bool equal;
416  ASSERT_NO_ERROR(fs::equivalent(Twine(TempPath), Twine(TempPath2), equal));
417  EXPECT_TRUE(equal);
418  ASSERT_NO_ERROR(fs::status(Twine(TempPath), A));
419  ASSERT_NO_ERROR(fs::status(Twine(TempPath2), B));
420  EXPECT_TRUE(fs::equivalent(A, B));
421
422  // Remove Temp1.
423  ::close(FileDescriptor);
424  ASSERT_NO_ERROR(fs::remove(Twine(TempPath)));
425
426  // Remove the hard link.
427  ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));
428
429  // Make sure Temp1 doesn't exist.
430  ASSERT_EQ(fs::access(Twine(TempPath), sys::fs::AccessMode::Exist),
431            errc::no_such_file_or_directory);
432
433#ifdef LLVM_ON_WIN32
434  // Path name > 260 chars should get an error.
435  const char *Path270 =
436    "abcdefghijklmnopqrstuvwxyz9abcdefghijklmnopqrstuvwxyz8"
437    "abcdefghijklmnopqrstuvwxyz7abcdefghijklmnopqrstuvwxyz6"
438    "abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz4"
439    "abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz2"
440    "abcdefghijklmnopqrstuvwxyz1abcdefghijklmnopqrstuvwxyz0";
441  EXPECT_EQ(fs::createUniqueFile(Path270, FileDescriptor, TempPath),
442            errc::invalid_argument);
443  // Relative path < 247 chars, no problem.
444  const char *Path216 =
445    "abcdefghijklmnopqrstuvwxyz7abcdefghijklmnopqrstuvwxyz6"
446    "abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz4"
447    "abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz2"
448    "abcdefghijklmnopqrstuvwxyz1abcdefghijklmnopqrstuvwxyz0";
449  ASSERT_NO_ERROR(fs::createTemporaryFile(Path216, "", TempPath));
450  ASSERT_NO_ERROR(fs::remove(Twine(TempPath)));
451#endif
452}
453
454TEST_F(FileSystemTest, CreateDir) {
455  ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "foo"));
456  ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "foo"));
457  ASSERT_EQ(fs::create_directory(Twine(TestDirectory) + "foo", false),
458            errc::file_exists);
459  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "foo"));
460
461#ifdef LLVM_ON_WIN32
462  // Prove that create_directories() can handle a pathname > 248 characters,
463  // which is the documented limit for CreateDirectory().
464  // (248 is MAX_PATH subtracting room for an 8.3 filename.)
465  // Generate a directory path guaranteed to fall into that range.
466  size_t TmpLen = TestDirectory.size();
467  const char *OneDir = "\\123456789";
468  size_t OneDirLen = strlen(OneDir);
469  ASSERT_LT(OneDirLen, 12U);
470  size_t NLevels = ((248 - TmpLen) / OneDirLen) + 1;
471  SmallString<260> LongDir(TestDirectory);
472  for (size_t I = 0; I < NLevels; ++I)
473    LongDir.append(OneDir);
474  ASSERT_NO_ERROR(fs::create_directories(Twine(LongDir)));
475  ASSERT_NO_ERROR(fs::create_directories(Twine(LongDir)));
476  ASSERT_EQ(fs::create_directories(Twine(LongDir), false),
477            errc::file_exists);
478  // Tidy up, "recursively" removing the directories.
479  StringRef ThisDir(LongDir);
480  for (size_t J = 0; J < NLevels; ++J) {
481    ASSERT_NO_ERROR(fs::remove(ThisDir));
482    ThisDir = path::parent_path(ThisDir);
483  }
484
485  // Similarly for a relative pathname.  Need to set the current directory to
486  // TestDirectory so that the one we create ends up in the right place.
487  char PreviousDir[260];
488  size_t PreviousDirLen = ::GetCurrentDirectoryA(260, PreviousDir);
489  ASSERT_GT(PreviousDirLen, 0U);
490  ASSERT_LT(PreviousDirLen, 260U);
491  ASSERT_NE(::SetCurrentDirectoryA(TestDirectory.c_str()), 0);
492  LongDir.clear();
493  // Generate a relative directory name with absolute length > 248.
494  size_t LongDirLen = 249 - TestDirectory.size();
495  LongDir.assign(LongDirLen, 'a');
496  ASSERT_NO_ERROR(fs::create_directory(Twine(LongDir)));
497  // While we're here, prove that .. and . handling works in these long paths.
498  const char *DotDotDirs = "\\..\\.\\b";
499  LongDir.append(DotDotDirs);
500  ASSERT_NO_ERROR(fs::create_directory("b"));
501  ASSERT_EQ(fs::create_directory(Twine(LongDir), false), errc::file_exists);
502  // And clean up.
503  ASSERT_NO_ERROR(fs::remove("b"));
504  ASSERT_NO_ERROR(fs::remove(
505    Twine(LongDir.substr(0, LongDir.size() - strlen(DotDotDirs)))));
506  ASSERT_NE(::SetCurrentDirectoryA(PreviousDir), 0);
507#endif
508}
509
510TEST_F(FileSystemTest, DirectoryIteration) {
511  std::error_code ec;
512  for (fs::directory_iterator i(".", ec), e; i != e; i.increment(ec))
513    ASSERT_NO_ERROR(ec);
514
515  // Create a known hierarchy to recurse over.
516  ASSERT_NO_ERROR(
517      fs::create_directories(Twine(TestDirectory) + "/recursive/a0/aa1"));
518  ASSERT_NO_ERROR(
519      fs::create_directories(Twine(TestDirectory) + "/recursive/a0/ab1"));
520  ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) +
521                                         "/recursive/dontlookhere/da1"));
522  ASSERT_NO_ERROR(
523      fs::create_directories(Twine(TestDirectory) + "/recursive/z0/za1"));
524  ASSERT_NO_ERROR(
525      fs::create_directories(Twine(TestDirectory) + "/recursive/pop/p1"));
526  typedef std::vector<std::string> v_t;
527  v_t visited;
528  for (fs::recursive_directory_iterator i(Twine(TestDirectory)
529         + "/recursive", ec), e; i != e; i.increment(ec)){
530    ASSERT_NO_ERROR(ec);
531    if (path::filename(i->path()) == "p1") {
532      i.pop();
533      // FIXME: recursive_directory_iterator should be more robust.
534      if (i == e) break;
535    }
536    if (path::filename(i->path()) == "dontlookhere")
537      i.no_push();
538    visited.push_back(path::filename(i->path()));
539  }
540  v_t::const_iterator a0 = std::find(visited.begin(), visited.end(), "a0");
541  v_t::const_iterator aa1 = std::find(visited.begin(), visited.end(), "aa1");
542  v_t::const_iterator ab1 = std::find(visited.begin(), visited.end(), "ab1");
543  v_t::const_iterator dontlookhere = std::find(visited.begin(), visited.end(),
544                                               "dontlookhere");
545  v_t::const_iterator da1 = std::find(visited.begin(), visited.end(), "da1");
546  v_t::const_iterator z0 = std::find(visited.begin(), visited.end(), "z0");
547  v_t::const_iterator za1 = std::find(visited.begin(), visited.end(), "za1");
548  v_t::const_iterator pop = std::find(visited.begin(), visited.end(), "pop");
549  v_t::const_iterator p1 = std::find(visited.begin(), visited.end(), "p1");
550
551  // Make sure that each path was visited correctly.
552  ASSERT_NE(a0, visited.end());
553  ASSERT_NE(aa1, visited.end());
554  ASSERT_NE(ab1, visited.end());
555  ASSERT_NE(dontlookhere, visited.end());
556  ASSERT_EQ(da1, visited.end()); // Not visited.
557  ASSERT_NE(z0, visited.end());
558  ASSERT_NE(za1, visited.end());
559  ASSERT_NE(pop, visited.end());
560  ASSERT_EQ(p1, visited.end()); // Not visited.
561
562  // Make sure that parents were visited before children. No other ordering
563  // guarantees can be made across siblings.
564  ASSERT_LT(a0, aa1);
565  ASSERT_LT(a0, ab1);
566  ASSERT_LT(z0, za1);
567
568  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0/aa1"));
569  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0/ab1"));
570  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0"));
571  ASSERT_NO_ERROR(
572      fs::remove(Twine(TestDirectory) + "/recursive/dontlookhere/da1"));
573  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/dontlookhere"));
574  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/pop/p1"));
575  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/pop"));
576  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/z0/za1"));
577  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/z0"));
578  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive"));
579}
580
581const char archive[] = "!<arch>\x0A";
582const char bitcode[] = "\xde\xc0\x17\x0b";
583const char coff_object[] = "\x00\x00......";
584const char coff_bigobj[] = "\x00\x00\xff\xff\x00\x02......"
585    "\xc7\xa1\xba\xd1\xee\xba\xa9\x4b\xaf\x20\xfa\xf6\x6a\xa4\xdc\xb8";
586const char coff_import_library[] = "\x00\x00\xff\xff....";
587const char elf_relocatable[] = { 0x7f, 'E', 'L', 'F', 1, 2, 1, 0, 0,
588                                 0,    0,   0,   0,   0, 0, 0, 0, 1 };
589const char macho_universal_binary[] = "\xca\xfe\xba\xbe...\0x00";
590const char macho_object[] = "\xfe\xed\xfa\xce..........\x00\x01";
591const char macho_executable[] = "\xfe\xed\xfa\xce..........\x00\x02";
592const char macho_fixed_virtual_memory_shared_lib[] =
593    "\xfe\xed\xfa\xce..........\x00\x03";
594const char macho_core[] = "\xfe\xed\xfa\xce..........\x00\x04";
595const char macho_preload_executable[] = "\xfe\xed\xfa\xce..........\x00\x05";
596const char macho_dynamically_linked_shared_lib[] =
597    "\xfe\xed\xfa\xce..........\x00\x06";
598const char macho_dynamic_linker[] = "\xfe\xed\xfa\xce..........\x00\x07";
599const char macho_bundle[] = "\xfe\xed\xfa\xce..........\x00\x08";
600const char macho_dsym_companion[] = "\xfe\xed\xfa\xce..........\x00\x0a";
601const char macho_kext_bundle[] = "\xfe\xed\xfa\xce..........\x00\x0b";
602const char windows_resource[] = "\x00\x00\x00\x00\x020\x00\x00\x00\xff";
603const char macho_dynamically_linked_shared_lib_stub[] =
604    "\xfe\xed\xfa\xce..........\x00\x09";
605
606TEST_F(FileSystemTest, Magic) {
607  struct type {
608    const char *filename;
609    const char *magic_str;
610    size_t magic_str_len;
611    fs::file_magic magic;
612  } types[] = {
613#define DEFINE(magic)                                           \
614    { #magic, magic, sizeof(magic), fs::file_magic::magic }
615    DEFINE(archive),
616    DEFINE(bitcode),
617    DEFINE(coff_object),
618    { "coff_bigobj", coff_bigobj, sizeof(coff_bigobj), fs::file_magic::coff_object },
619    DEFINE(coff_import_library),
620    DEFINE(elf_relocatable),
621    DEFINE(macho_universal_binary),
622    DEFINE(macho_object),
623    DEFINE(macho_executable),
624    DEFINE(macho_fixed_virtual_memory_shared_lib),
625    DEFINE(macho_core),
626    DEFINE(macho_preload_executable),
627    DEFINE(macho_dynamically_linked_shared_lib),
628    DEFINE(macho_dynamic_linker),
629    DEFINE(macho_bundle),
630    DEFINE(macho_dynamically_linked_shared_lib_stub),
631    DEFINE(macho_dsym_companion),
632    DEFINE(macho_kext_bundle),
633    DEFINE(windows_resource)
634#undef DEFINE
635    };
636
637  // Create some files filled with magic.
638  for (type *i = types, *e = types + (sizeof(types) / sizeof(type)); i != e;
639                                                                     ++i) {
640    SmallString<128> file_pathname(TestDirectory);
641    path::append(file_pathname, i->filename);
642    std::error_code EC;
643    raw_fd_ostream file(file_pathname, EC, sys::fs::F_None);
644    ASSERT_FALSE(file.has_error());
645    StringRef magic(i->magic_str, i->magic_str_len);
646    file << magic;
647    file.close();
648    EXPECT_EQ(i->magic, fs::identify_magic(magic));
649    ASSERT_NO_ERROR(fs::remove(Twine(file_pathname)));
650  }
651}
652
653#ifdef LLVM_ON_WIN32
654TEST_F(FileSystemTest, CarriageReturn) {
655  SmallString<128> FilePathname(TestDirectory);
656  std::error_code EC;
657  path::append(FilePathname, "test");
658
659  {
660    raw_fd_ostream File(FilePathname, EC, sys::fs::F_Text);
661    ASSERT_NO_ERROR(EC);
662    File << '\n';
663  }
664  {
665    auto Buf = MemoryBuffer::getFile(FilePathname.str());
666    EXPECT_TRUE((bool)Buf);
667    EXPECT_EQ(Buf.get()->getBuffer(), "\r\n");
668  }
669
670  {
671    raw_fd_ostream File(FilePathname, EC, sys::fs::F_None);
672    ASSERT_NO_ERROR(EC);
673    File << '\n';
674  }
675  {
676    auto Buf = MemoryBuffer::getFile(FilePathname.str());
677    EXPECT_TRUE((bool)Buf);
678    EXPECT_EQ(Buf.get()->getBuffer(), "\n");
679  }
680  ASSERT_NO_ERROR(fs::remove(Twine(FilePathname)));
681}
682#endif
683
684TEST_F(FileSystemTest, Resize) {
685  int FD;
686  SmallString<64> TempPath;
687  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath));
688  ASSERT_NO_ERROR(fs::resize_file(FD, 123));
689  fs::file_status Status;
690  ASSERT_NO_ERROR(fs::status(FD, Status));
691  ASSERT_EQ(Status.getSize(), 123U);
692}
693
694TEST_F(FileSystemTest, FileMapping) {
695  // Create a temp file.
696  int FileDescriptor;
697  SmallString<64> TempPath;
698  ASSERT_NO_ERROR(
699      fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));
700  unsigned Size = 4096;
701  ASSERT_NO_ERROR(fs::resize_file(FileDescriptor, Size));
702
703  // Map in temp file and add some content
704  std::error_code EC;
705  StringRef Val("hello there");
706  {
707    fs::mapped_file_region mfr(FileDescriptor,
708                               fs::mapped_file_region::readwrite, Size, 0, EC);
709    ASSERT_NO_ERROR(EC);
710    std::copy(Val.begin(), Val.end(), mfr.data());
711    // Explicitly add a 0.
712    mfr.data()[Val.size()] = 0;
713    // Unmap temp file
714  }
715
716  // Map it back in read-only
717  int FD;
718  EC = fs::openFileForRead(Twine(TempPath), FD);
719  ASSERT_NO_ERROR(EC);
720  fs::mapped_file_region mfr(FD, fs::mapped_file_region::readonly, Size, 0, EC);
721  ASSERT_NO_ERROR(EC);
722
723  // Verify content
724  EXPECT_EQ(StringRef(mfr.const_data()), Val);
725
726  // Unmap temp file
727  fs::mapped_file_region m(FD, fs::mapped_file_region::readonly, Size, 0, EC);
728  ASSERT_NO_ERROR(EC);
729  ASSERT_EQ(close(FD), 0);
730}
731
732TEST(Support, NormalizePath) {
733#if defined(LLVM_ON_WIN32)
734#define EXPECT_PATH_IS(path__, windows__, not_windows__)                        \
735  EXPECT_EQ(path__, windows__);
736#else
737#define EXPECT_PATH_IS(path__, windows__, not_windows__)                        \
738  EXPECT_EQ(path__, not_windows__);
739#endif
740
741  SmallString<64> Path1("a");
742  SmallString<64> Path2("a/b");
743  SmallString<64> Path3("a\\b");
744  SmallString<64> Path4("a\\\\b");
745  SmallString<64> Path5("\\a");
746  SmallString<64> Path6("a\\");
747
748  path::native(Path1);
749  EXPECT_PATH_IS(Path1, "a", "a");
750
751  path::native(Path2);
752  EXPECT_PATH_IS(Path2, "a\\b", "a/b");
753
754  path::native(Path3);
755  EXPECT_PATH_IS(Path3, "a\\b", "a/b");
756
757  path::native(Path4);
758  EXPECT_PATH_IS(Path4, "a\\\\b", "a\\\\b");
759
760  path::native(Path5);
761  EXPECT_PATH_IS(Path5, "\\a", "/a");
762
763  path::native(Path6);
764  EXPECT_PATH_IS(Path6, "a\\", "a/");
765
766#undef EXPECT_PATH_IS
767}
768} // anonymous namespace
769