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