1 //===-- FileCollectorTest.cpp -----------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "gmock/gmock.h" 10 #include "gtest/gtest.h" 11 12 #include "llvm/Support/FileCollector.h" 13 #include "llvm/Support/FileSystem.h" 14 15 using namespace llvm; 16 17 namespace llvm { 18 namespace vfs { 19 inline bool operator==(const llvm::vfs::YAMLVFSEntry &LHS, 20 const llvm::vfs::YAMLVFSEntry &RHS) { 21 return LHS.VPath == RHS.VPath && LHS.RPath == RHS.RPath; 22 } 23 } // namespace vfs 24 } // namespace llvm 25 26 namespace { 27 class TestingFileCollector : public FileCollector { 28 public: 29 using FileCollector::FileCollector; 30 using FileCollector::Root; 31 using FileCollector::Seen; 32 using FileCollector::SymlinkMap; 33 using FileCollector::VFSWriter; 34 35 bool hasSeen(StringRef fs) { 36 return Seen.find(fs) != Seen.end(); 37 } 38 }; 39 40 struct ScopedDir { 41 SmallString<128> Path; 42 ScopedDir(const Twine &Name, bool Unique = false) { 43 std::error_code EC; 44 if (Unique) { 45 EC = llvm::sys::fs::createUniqueDirectory(Name, Path); 46 } else { 47 Path = Name.str(); 48 EC = llvm::sys::fs::create_directory(Twine(Path)); 49 } 50 if (EC) 51 Path = ""; 52 EXPECT_FALSE(EC); 53 // Ensure the path is the real path so tests can use it to compare against 54 // realpath output. 55 SmallString<128> RealPath; 56 if (!llvm::sys::fs::real_path(Path, RealPath)) 57 Path.swap(RealPath); 58 } 59 ~ScopedDir() { 60 if (Path != "") { 61 EXPECT_FALSE(llvm::sys::fs::remove_directories(Path.str())); 62 } 63 } 64 operator StringRef() { return Path.str(); } 65 }; 66 67 struct ScopedLink { 68 SmallString<128> Path; 69 ScopedLink(const Twine &To, const Twine &From) { 70 Path = From.str(); 71 std::error_code EC = sys::fs::create_link(To, From); 72 if (EC) 73 Path = ""; 74 EXPECT_FALSE(EC); 75 } 76 ~ScopedLink() { 77 if (Path != "") { 78 EXPECT_FALSE(llvm::sys::fs::remove(Path.str())); 79 } 80 } 81 operator StringRef() { return Path.str(); } 82 }; 83 84 struct ScopedFile { 85 SmallString<128> Path; 86 ScopedFile(const Twine &Name) { 87 std::error_code EC; 88 EC = llvm::sys::fs::createUniqueFile(Name, Path); 89 if (EC) 90 Path = ""; 91 EXPECT_FALSE(EC); 92 } 93 ~ScopedFile() { 94 if (Path != "") { 95 EXPECT_FALSE(llvm::sys::fs::remove(Path.str())); 96 } 97 } 98 operator StringRef() { return Path.str(); } 99 }; 100 } // end anonymous namespace 101 102 TEST(FileCollectorTest, addFile) { 103 ScopedDir root("add_file_root", true); 104 std::string root_fs = root.Path.str(); 105 TestingFileCollector FileCollector(root_fs, root_fs); 106 107 FileCollector.addFile("/path/to/a"); 108 FileCollector.addFile("/path/to/b"); 109 FileCollector.addFile("/path/to/c"); 110 111 // Make sure the root is correct. 112 EXPECT_EQ(FileCollector.Root, root_fs); 113 114 // Make sure we've seen all the added files. 115 EXPECT_TRUE(FileCollector.hasSeen("/path/to/a")); 116 EXPECT_TRUE(FileCollector.hasSeen("/path/to/b")); 117 EXPECT_TRUE(FileCollector.hasSeen("/path/to/c")); 118 119 // Make sure we've only seen the added files. 120 EXPECT_FALSE(FileCollector.hasSeen("/path/to/d")); 121 } 122 123 TEST(FileCollectorTest, copyFiles) { 124 ScopedDir file_root("file_root", true); 125 ScopedFile a(file_root + "/aaa"); 126 ScopedFile b(file_root + "/bbb"); 127 ScopedFile c(file_root + "/ccc"); 128 129 // Create file collector and add files. 130 ScopedDir root("copy_files_root", true); 131 std::string root_fs = root.Path.str(); 132 TestingFileCollector FileCollector(root_fs, root_fs); 133 FileCollector.addFile(a.Path); 134 FileCollector.addFile(b.Path); 135 FileCollector.addFile(c.Path); 136 137 // Make sure we can copy the files. 138 std::error_code ec = FileCollector.copyFiles(true); 139 EXPECT_FALSE(ec); 140 141 // Now add a bogus file and make sure we error out. 142 FileCollector.addFile("/some/bogus/file"); 143 ec = FileCollector.copyFiles(true); 144 EXPECT_TRUE(ec); 145 146 // However, if stop_on_error is true the copy should still succeed. 147 ec = FileCollector.copyFiles(false); 148 EXPECT_FALSE(ec); 149 } 150 151 TEST(FileCollectorTest, recordAndConstructDirectory) { 152 ScopedDir file_root("dir_root", true); 153 ScopedDir subdir(file_root + "/subdir"); 154 ScopedDir subdir2(file_root + "/subdir2"); 155 ScopedFile a(subdir2 + "/a"); 156 157 // Create file collector and add files. 158 ScopedDir root("copy_files_root", true); 159 std::string root_fs = root.Path.str(); 160 TestingFileCollector FileCollector(root_fs, root_fs); 161 FileCollector.addFile(a.Path); 162 163 // The empty directory isn't seen until we add it. 164 EXPECT_TRUE(FileCollector.hasSeen(a.Path)); 165 EXPECT_FALSE(FileCollector.hasSeen(subdir.Path)); 166 167 FileCollector.addFile(subdir.Path); 168 EXPECT_TRUE(FileCollector.hasSeen(subdir.Path)); 169 170 // Make sure we can construct the directory. 171 std::error_code ec = FileCollector.copyFiles(true); 172 EXPECT_FALSE(ec); 173 bool IsDirectory = false; 174 llvm::SmallString<128> SubdirInRoot = root.Path; 175 llvm::sys::path::append(SubdirInRoot, 176 llvm::sys::path::relative_path(subdir.Path)); 177 ec = sys::fs::is_directory(SubdirInRoot, IsDirectory); 178 EXPECT_FALSE(ec); 179 ASSERT_TRUE(IsDirectory); 180 } 181 182 #ifndef _WIN32 183 TEST(FileCollectorTest, Symlinks) { 184 // Root where the original files live. 185 ScopedDir file_root("file_root", true); 186 187 // Create some files in the file root. 188 ScopedFile a(file_root + "/aaa"); 189 ScopedFile b(file_root + "/bbb"); 190 ScopedFile c(file_root + "/ccc"); 191 192 // Create a directory foo with file ddd. 193 ScopedDir foo(file_root + "/foo"); 194 ScopedFile d(foo + "/ddd"); 195 196 // Create a file eee in the foo's parent directory. 197 ScopedFile e(foo + "/../eee"); 198 199 // Create a symlink bar pointing to foo. 200 ScopedLink symlink(file_root + "/foo", file_root + "/bar"); 201 202 // Root where files are copied to. 203 ScopedDir reproducer_root("reproducer_root", true); 204 std::string root_fs = reproducer_root.Path.str(); 205 TestingFileCollector FileCollector(root_fs, root_fs); 206 207 // Add all the files to the collector. 208 FileCollector.addFile(a.Path); 209 FileCollector.addFile(b.Path); 210 FileCollector.addFile(c.Path); 211 FileCollector.addFile(d.Path); 212 FileCollector.addFile(e.Path); 213 FileCollector.addFile(file_root + "/bar/ddd"); 214 215 auto mapping = FileCollector.VFSWriter.getMappings(); 216 217 { 218 // Make sure the common case works. 219 std::string vpath = (file_root + "/aaa").str(); 220 std::string rpath = (reproducer_root.Path + file_root.Path + "/aaa").str(); 221 printf("%s -> %s\n", vpath.c_str(), rpath.c_str()); 222 EXPECT_THAT(mapping, testing::Contains(vfs::YAMLVFSEntry(vpath, rpath))); 223 } 224 225 { 226 // Make sure the virtual path points to the real source path. 227 std::string vpath = (file_root + "/bar/ddd").str(); 228 std::string rpath = 229 (reproducer_root.Path + file_root.Path + "/foo/ddd").str(); 230 printf("%s -> %s\n", vpath.c_str(), rpath.c_str()); 231 EXPECT_THAT(mapping, testing::Contains(vfs::YAMLVFSEntry(vpath, rpath))); 232 } 233 234 { 235 // Make sure that .. is removed from the source path. 236 std::string vpath = (file_root + "/eee").str(); 237 std::string rpath = (reproducer_root.Path + file_root.Path + "/eee").str(); 238 printf("%s -> %s\n", vpath.c_str(), rpath.c_str()); 239 EXPECT_THAT(mapping, testing::Contains(vfs::YAMLVFSEntry(vpath, rpath))); 240 } 241 } 242 #endif 243