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/ErrorHandling.h" 12 #include "llvm/Support/FileSystem.h" 13 #include "llvm/Support/MemoryBuffer.h" 14 #include "llvm/Support/raw_ostream.h" 15 #include "gtest/gtest.h" 16 17 using namespace llvm; 18 using namespace llvm::sys; 19 20 #define ASSERT_NO_ERROR(x) \ 21 if (error_code ASSERT_NO_ERROR_ec = x) { \ 22 SmallString<128> MessageStorage; \ 23 raw_svector_ostream Message(MessageStorage); \ 24 Message << #x ": did not return errc::success.\n" \ 25 << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n" \ 26 << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n"; \ 27 GTEST_FATAL_FAILURE_(MessageStorage.c_str()); \ 28 } else {} 29 30 namespace { 31 32 TEST(is_separator, Works) { 33 EXPECT_TRUE(path::is_separator('/')); 34 EXPECT_FALSE(path::is_separator('\0')); 35 EXPECT_FALSE(path::is_separator('-')); 36 EXPECT_FALSE(path::is_separator(' ')); 37 38 #ifdef LLVM_ON_WIN32 39 EXPECT_TRUE(path::is_separator('\\')); 40 #else 41 EXPECT_FALSE(path::is_separator('\\')); 42 #endif 43 } 44 45 TEST(Support, Path) { 46 SmallVector<StringRef, 40> paths; 47 paths.push_back(""); 48 paths.push_back("."); 49 paths.push_back(".."); 50 paths.push_back("foo"); 51 paths.push_back("/"); 52 paths.push_back("/foo"); 53 paths.push_back("foo/"); 54 paths.push_back("/foo/"); 55 paths.push_back("foo/bar"); 56 paths.push_back("/foo/bar"); 57 paths.push_back("//net"); 58 paths.push_back("//net/foo"); 59 paths.push_back("///foo///"); 60 paths.push_back("///foo///bar"); 61 paths.push_back("/."); 62 paths.push_back("./"); 63 paths.push_back("/.."); 64 paths.push_back("../"); 65 paths.push_back("foo/."); 66 paths.push_back("foo/.."); 67 paths.push_back("foo/./"); 68 paths.push_back("foo/./bar"); 69 paths.push_back("foo/.."); 70 paths.push_back("foo/../"); 71 paths.push_back("foo/../bar"); 72 paths.push_back("c:"); 73 paths.push_back("c:/"); 74 paths.push_back("c:foo"); 75 paths.push_back("c:/foo"); 76 paths.push_back("c:foo/"); 77 paths.push_back("c:/foo/"); 78 paths.push_back("c:/foo/bar"); 79 paths.push_back("prn:"); 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/"); 86 paths.push_back("c:/foo\\bar"); 87 88 for (SmallVector<StringRef, 40>::const_iterator i = paths.begin(), 89 e = paths.end(); 90 i != e; 91 ++i) { 92 for (sys::path::const_iterator ci = sys::path::begin(*i), 93 ce = sys::path::end(*i); 94 ci != ce; 95 ++ci) { 96 ASSERT_FALSE(ci->empty()); 97 } 98 99 #if 0 // Valgrind is whining about this. 100 outs() << " Reverse Iteration: ["; 101 for (sys::path::reverse_iterator ci = sys::path::rbegin(*i), 102 ce = sys::path::rend(*i); 103 ci != ce; 104 ++ci) { 105 outs() << *ci << ','; 106 } 107 outs() << "]\n"; 108 #endif 109 110 path::has_root_path(*i); 111 path::root_path(*i); 112 path::has_root_name(*i); 113 path::root_name(*i); 114 path::has_root_directory(*i); 115 path::root_directory(*i); 116 path::has_parent_path(*i); 117 path::parent_path(*i); 118 path::has_filename(*i); 119 path::filename(*i); 120 path::has_stem(*i); 121 path::stem(*i); 122 path::has_extension(*i); 123 path::extension(*i); 124 path::is_absolute(*i); 125 path::is_relative(*i); 126 127 SmallString<128> temp_store; 128 temp_store = *i; 129 ASSERT_NO_ERROR(fs::make_absolute(temp_store)); 130 temp_store = *i; 131 path::remove_filename(temp_store); 132 133 temp_store = *i; 134 path::replace_extension(temp_store, "ext"); 135 StringRef filename(temp_store.begin(), temp_store.size()), stem, ext; 136 stem = path::stem(filename); 137 ext = path::extension(filename); 138 EXPECT_EQ(*(--sys::path::end(filename)), (stem + ext).str()); 139 140 path::native(*i, temp_store); 141 } 142 } 143 144 TEST(Support, RelativePathIterator) { 145 SmallString<64> Path(StringRef("c/d/e/foo.txt")); 146 typedef SmallVector<StringRef, 4> PathComponents; 147 PathComponents ExpectedPathComponents; 148 PathComponents ActualPathComponents; 149 150 StringRef(Path).split(ExpectedPathComponents, "/"); 151 152 for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E; 153 ++I) { 154 ActualPathComponents.push_back(*I); 155 } 156 157 ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size()); 158 159 for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) { 160 EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str()); 161 } 162 } 163 164 TEST(Support, AbsolutePathIterator) { 165 SmallString<64> Path(StringRef("/c/d/e/foo.txt")); 166 typedef SmallVector<StringRef, 4> PathComponents; 167 PathComponents ExpectedPathComponents; 168 PathComponents ActualPathComponents; 169 170 StringRef(Path).split(ExpectedPathComponents, "/"); 171 172 // The root path will also be a component when iterating 173 ExpectedPathComponents[0] = "/"; 174 175 for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E; 176 ++I) { 177 ActualPathComponents.push_back(*I); 178 } 179 180 ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size()); 181 182 for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) { 183 EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str()); 184 } 185 } 186 187 #ifdef LLVM_ON_WIN32 188 TEST(Support, AbsolutePathIteratorWin32) { 189 SmallString<64> Path(StringRef("c:\\c\\e\\foo.txt")); 190 typedef SmallVector<StringRef, 4> PathComponents; 191 PathComponents ExpectedPathComponents; 192 PathComponents ActualPathComponents; 193 194 StringRef(Path).split(ExpectedPathComponents, "\\"); 195 196 // The root path (which comes after the drive name) will also be a component 197 // when iterating. 198 ExpectedPathComponents.insert(ExpectedPathComponents.begin()+1, "\\"); 199 200 for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E; 201 ++I) { 202 ActualPathComponents.push_back(*I); 203 } 204 205 ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size()); 206 207 for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) { 208 EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str()); 209 } 210 } 211 #endif // LLVM_ON_WIN32 212 213 class FileSystemTest : public testing::Test { 214 protected: 215 /// Unique temporary directory in which all created filesystem entities must 216 /// be placed. It is recursively removed at the end of each test. 217 SmallString<128> TestDirectory; 218 219 virtual void SetUp() { 220 ASSERT_NO_ERROR( 221 fs::createUniqueDirectory("file-system-test", TestDirectory)); 222 // We don't care about this specific file. 223 errs() << "Test Directory: " << TestDirectory << '\n'; 224 errs().flush(); 225 } 226 227 virtual void TearDown() { 228 uint32_t removed; 229 ASSERT_NO_ERROR(fs::remove_all(TestDirectory.str(), removed)); 230 } 231 }; 232 233 TEST_F(FileSystemTest, Unique) { 234 // Create a temp file. 235 int FileDescriptor; 236 SmallString<64> TempPath; 237 ASSERT_NO_ERROR( 238 fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath)); 239 240 // The same file should return an identical unique id. 241 fs::UniqueID F1, F2; 242 ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), F1)); 243 ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), F2)); 244 ASSERT_EQ(F1, F2); 245 246 // Different files should return different unique ids. 247 int FileDescriptor2; 248 SmallString<64> TempPath2; 249 ASSERT_NO_ERROR( 250 fs::createTemporaryFile("prefix", "temp", FileDescriptor2, TempPath2)); 251 252 fs::UniqueID D; 253 ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath2), D)); 254 ASSERT_NE(D, F1); 255 ::close(FileDescriptor2); 256 257 ASSERT_NO_ERROR(fs::remove(Twine(TempPath2))); 258 259 // Two paths representing the same file on disk should still provide the 260 // same unique id. We can test this by making a hard link. 261 ASSERT_NO_ERROR(fs::create_hard_link(Twine(TempPath), Twine(TempPath2))); 262 fs::UniqueID D2; 263 ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath2), D2)); 264 ASSERT_EQ(D2, F1); 265 266 ::close(FileDescriptor); 267 268 SmallString<128> Dir1; 269 ASSERT_NO_ERROR( 270 fs::createUniqueDirectory("dir1", Dir1)); 271 ASSERT_NO_ERROR(fs::getUniqueID(Dir1.c_str(), F1)); 272 ASSERT_NO_ERROR(fs::getUniqueID(Dir1.c_str(), F2)); 273 ASSERT_EQ(F1, F2); 274 275 SmallString<128> Dir2; 276 ASSERT_NO_ERROR( 277 fs::createUniqueDirectory("dir2", Dir2)); 278 ASSERT_NO_ERROR(fs::getUniqueID(Dir2.c_str(), F2)); 279 ASSERT_NE(F1, F2); 280 } 281 282 TEST_F(FileSystemTest, TempFiles) { 283 // Create a temp file. 284 int FileDescriptor; 285 SmallString<64> TempPath; 286 ASSERT_NO_ERROR( 287 fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath)); 288 289 // Make sure it exists. 290 bool TempFileExists; 291 ASSERT_NO_ERROR(sys::fs::exists(Twine(TempPath), TempFileExists)); 292 EXPECT_TRUE(TempFileExists); 293 294 // Create another temp tile. 295 int FD2; 296 SmallString<64> TempPath2; 297 ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD2, TempPath2)); 298 ASSERT_TRUE(TempPath2.endswith(".temp")); 299 ASSERT_NE(TempPath.str(), TempPath2.str()); 300 301 fs::file_status A, B; 302 ASSERT_NO_ERROR(fs::status(Twine(TempPath), A)); 303 ASSERT_NO_ERROR(fs::status(Twine(TempPath2), B)); 304 EXPECT_FALSE(fs::equivalent(A, B)); 305 306 ::close(FD2); 307 308 // Remove Temp2. 309 ASSERT_NO_ERROR(fs::remove(Twine(TempPath2), TempFileExists)); 310 EXPECT_TRUE(TempFileExists); 311 312 error_code EC = fs::status(TempPath2.c_str(), B); 313 EXPECT_EQ(EC, errc::no_such_file_or_directory); 314 EXPECT_EQ(B.type(), fs::file_type::file_not_found); 315 316 // Make sure Temp2 doesn't exist. 317 ASSERT_NO_ERROR(fs::exists(Twine(TempPath2), TempFileExists)); 318 EXPECT_FALSE(TempFileExists); 319 320 SmallString<64> TempPath3; 321 ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "", TempPath3)); 322 ASSERT_FALSE(TempPath3.endswith(".")); 323 324 // Create a hard link to Temp1. 325 ASSERT_NO_ERROR(fs::create_hard_link(Twine(TempPath), Twine(TempPath2))); 326 bool equal; 327 ASSERT_NO_ERROR(fs::equivalent(Twine(TempPath), Twine(TempPath2), equal)); 328 EXPECT_TRUE(equal); 329 ASSERT_NO_ERROR(fs::status(Twine(TempPath), A)); 330 ASSERT_NO_ERROR(fs::status(Twine(TempPath2), B)); 331 EXPECT_TRUE(fs::equivalent(A, B)); 332 333 // Remove Temp1. 334 ::close(FileDescriptor); 335 ASSERT_NO_ERROR(fs::remove(Twine(TempPath), TempFileExists)); 336 EXPECT_TRUE(TempFileExists); 337 338 // Remove the hard link. 339 ASSERT_NO_ERROR(fs::remove(Twine(TempPath2), TempFileExists)); 340 EXPECT_TRUE(TempFileExists); 341 342 // Make sure Temp1 doesn't exist. 343 ASSERT_NO_ERROR(fs::exists(Twine(TempPath), TempFileExists)); 344 EXPECT_FALSE(TempFileExists); 345 346 #ifdef LLVM_ON_WIN32 347 // Path name > 260 chars should get an error. 348 const char *Path270 = 349 "abcdefghijklmnopqrstuvwxyz9abcdefghijklmnopqrstuvwxyz8" 350 "abcdefghijklmnopqrstuvwxyz7abcdefghijklmnopqrstuvwxyz6" 351 "abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz4" 352 "abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz2" 353 "abcdefghijklmnopqrstuvwxyz1abcdefghijklmnopqrstuvwxyz0"; 354 EXPECT_EQ(fs::createUniqueFile(Twine(Path270), FileDescriptor, TempPath), 355 windows_error::path_not_found); 356 #endif 357 } 358 359 TEST_F(FileSystemTest, DirectoryIteration) { 360 error_code ec; 361 for (fs::directory_iterator i(".", ec), e; i != e; i.increment(ec)) 362 ASSERT_NO_ERROR(ec); 363 364 // Create a known hierarchy to recurse over. 365 bool existed; 366 ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) 367 + "/recursive/a0/aa1", existed)); 368 ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) 369 + "/recursive/a0/ab1", existed)); 370 ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) 371 + "/recursive/dontlookhere/da1", existed)); 372 ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) 373 + "/recursive/z0/za1", existed)); 374 ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) 375 + "/recursive/pop/p1", existed)); 376 typedef std::vector<std::string> v_t; 377 v_t visited; 378 for (fs::recursive_directory_iterator i(Twine(TestDirectory) 379 + "/recursive", ec), e; i != e; i.increment(ec)){ 380 ASSERT_NO_ERROR(ec); 381 if (path::filename(i->path()) == "p1") { 382 i.pop(); 383 // FIXME: recursive_directory_iterator should be more robust. 384 if (i == e) break; 385 } 386 if (path::filename(i->path()) == "dontlookhere") 387 i.no_push(); 388 visited.push_back(path::filename(i->path())); 389 } 390 v_t::const_iterator a0 = std::find(visited.begin(), visited.end(), "a0"); 391 v_t::const_iterator aa1 = std::find(visited.begin(), visited.end(), "aa1"); 392 v_t::const_iterator ab1 = std::find(visited.begin(), visited.end(), "ab1"); 393 v_t::const_iterator dontlookhere = std::find(visited.begin(), visited.end(), 394 "dontlookhere"); 395 v_t::const_iterator da1 = std::find(visited.begin(), visited.end(), "da1"); 396 v_t::const_iterator z0 = std::find(visited.begin(), visited.end(), "z0"); 397 v_t::const_iterator za1 = std::find(visited.begin(), visited.end(), "za1"); 398 v_t::const_iterator pop = std::find(visited.begin(), visited.end(), "pop"); 399 v_t::const_iterator p1 = std::find(visited.begin(), visited.end(), "p1"); 400 401 // Make sure that each path was visited correctly. 402 ASSERT_NE(a0, visited.end()); 403 ASSERT_NE(aa1, visited.end()); 404 ASSERT_NE(ab1, visited.end()); 405 ASSERT_NE(dontlookhere, visited.end()); 406 ASSERT_EQ(da1, visited.end()); // Not visited. 407 ASSERT_NE(z0, visited.end()); 408 ASSERT_NE(za1, visited.end()); 409 ASSERT_NE(pop, visited.end()); 410 ASSERT_EQ(p1, visited.end()); // Not visited. 411 412 // Make sure that parents were visited before children. No other ordering 413 // guarantees can be made across siblings. 414 ASSERT_LT(a0, aa1); 415 ASSERT_LT(a0, ab1); 416 ASSERT_LT(z0, za1); 417 } 418 419 const char archive[] = "!<arch>\x0A"; 420 const char bitcode[] = "\xde\xc0\x17\x0b"; 421 const char coff_object[] = "\x00\x00......"; 422 const char coff_import_library[] = "\x00\x00\xff\xff...."; 423 const char elf_relocatable[] = { 0x7f, 'E', 'L', 'F', 1, 2, 1, 0, 0, 424 0, 0, 0, 0, 0, 0, 0, 0, 1 }; 425 const char macho_universal_binary[] = "\xca\xfe\xba\xbe...\0x00"; 426 const char macho_object[] = "\xfe\xed\xfa\xce..........\x00\x01"; 427 const char macho_executable[] = "\xfe\xed\xfa\xce..........\x00\x02"; 428 const char macho_fixed_virtual_memory_shared_lib[] = 429 "\xfe\xed\xfa\xce..........\x00\x03"; 430 const char macho_core[] = "\xfe\xed\xfa\xce..........\x00\x04"; 431 const char macho_preload_executable[] = "\xfe\xed\xfa\xce..........\x00\x05"; 432 const char macho_dynamically_linked_shared_lib[] = 433 "\xfe\xed\xfa\xce..........\x00\x06"; 434 const char macho_dynamic_linker[] = "\xfe\xed\xfa\xce..........\x00\x07"; 435 const char macho_bundle[] = "\xfe\xed\xfa\xce..........\x00\x08"; 436 const char macho_dsym_companion[] = "\xfe\xed\xfa\xce..........\x00\x0a"; 437 const char windows_resource[] = "\x00\x00\x00\x00\x020\x00\x00\x00\xff"; 438 439 TEST_F(FileSystemTest, Magic) { 440 struct type { 441 const char *filename; 442 const char *magic_str; 443 size_t magic_str_len; 444 fs::file_magic magic; 445 } types[] = { 446 #define DEFINE(magic) \ 447 { #magic, magic, sizeof(magic), fs::file_magic::magic } 448 DEFINE(archive), 449 DEFINE(bitcode), 450 DEFINE(coff_object), 451 DEFINE(coff_import_library), 452 DEFINE(elf_relocatable), 453 DEFINE(macho_universal_binary), 454 DEFINE(macho_object), 455 DEFINE(macho_executable), 456 DEFINE(macho_fixed_virtual_memory_shared_lib), 457 DEFINE(macho_core), 458 DEFINE(macho_preload_executable), 459 DEFINE(macho_dynamically_linked_shared_lib), 460 DEFINE(macho_dynamic_linker), 461 DEFINE(macho_bundle), 462 DEFINE(macho_dsym_companion), 463 DEFINE(windows_resource) 464 #undef DEFINE 465 }; 466 467 // Create some files filled with magic. 468 for (type *i = types, *e = types + (sizeof(types) / sizeof(type)); i != e; 469 ++i) { 470 SmallString<128> file_pathname(TestDirectory); 471 path::append(file_pathname, i->filename); 472 std::string ErrMsg; 473 raw_fd_ostream file(file_pathname.c_str(), ErrMsg, sys::fs::F_Binary); 474 ASSERT_FALSE(file.has_error()); 475 StringRef magic(i->magic_str, i->magic_str_len); 476 file << magic; 477 file.close(); 478 bool res = false; 479 ASSERT_NO_ERROR(fs::has_magic(file_pathname.c_str(), magic, res)); 480 EXPECT_TRUE(res); 481 EXPECT_EQ(i->magic, fs::identify_magic(magic)); 482 } 483 } 484 485 #ifdef LLVM_ON_WIN32 486 TEST_F(FileSystemTest, CarriageReturn) { 487 SmallString<128> FilePathname(TestDirectory); 488 std::string ErrMsg; 489 path::append(FilePathname, "test"); 490 491 { 492 raw_fd_ostream File(FilePathname.c_str(), ErrMsg); 493 EXPECT_EQ(ErrMsg, ""); 494 File << '\n'; 495 } 496 { 497 OwningPtr<MemoryBuffer> Buf; 498 MemoryBuffer::getFile(FilePathname.c_str(), Buf); 499 EXPECT_EQ(Buf->getBuffer(), "\r\n"); 500 } 501 502 { 503 raw_fd_ostream File(FilePathname.c_str(), ErrMsg, sys::fs::F_Binary); 504 EXPECT_EQ(ErrMsg, ""); 505 File << '\n'; 506 } 507 { 508 OwningPtr<MemoryBuffer> Buf; 509 MemoryBuffer::getFile(FilePathname.c_str(), Buf); 510 EXPECT_EQ(Buf->getBuffer(), "\n"); 511 } 512 } 513 #endif 514 515 TEST_F(FileSystemTest, FileMapping) { 516 // Create a temp file. 517 int FileDescriptor; 518 SmallString<64> TempPath; 519 ASSERT_NO_ERROR( 520 fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath)); 521 // Map in temp file and add some content 522 error_code EC; 523 StringRef Val("hello there"); 524 { 525 fs::mapped_file_region mfr(FileDescriptor, 526 true, 527 fs::mapped_file_region::readwrite, 528 4096, 529 0, 530 EC); 531 ASSERT_NO_ERROR(EC); 532 std::copy(Val.begin(), Val.end(), mfr.data()); 533 // Explicitly add a 0. 534 mfr.data()[Val.size()] = 0; 535 // Unmap temp file 536 } 537 538 // Map it back in read-only 539 fs::mapped_file_region mfr(Twine(TempPath), 540 fs::mapped_file_region::readonly, 541 0, 542 0, 543 EC); 544 ASSERT_NO_ERROR(EC); 545 546 // Verify content 547 EXPECT_EQ(StringRef(mfr.const_data()), Val); 548 549 // Unmap temp file 550 551 #if LLVM_HAS_RVALUE_REFERENCES 552 fs::mapped_file_region m(Twine(TempPath), 553 fs::mapped_file_region::readonly, 554 0, 555 0, 556 EC); 557 ASSERT_NO_ERROR(EC); 558 const char *Data = m.const_data(); 559 fs::mapped_file_region mfrrv(llvm_move(m)); 560 EXPECT_EQ(mfrrv.const_data(), Data); 561 #endif 562 } 563 } // anonymous namespace 564