unittests/Support/FileCollectorTest.cpp

   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 TEST(FileCollectorTest, recordVFSAccesses) {
 183   ScopedDir file_root("dir_root", true);
 184   ScopedDir subdir(file_root + "/subdir");
 185   ScopedDir subdir2(file_root + "/subdir2");
 186   ScopedFile a(subdir2 + "/a");
 187   ScopedFile b(file_root + "/b");
 188   ScopedDir subdir3(file_root + "/subdir3");
 189   ScopedFile subdir3a(subdir3 + "/aa");
 190   ScopedDir subdir3b(subdir3 + "/subdirb");
 191   {
 192     ScopedFile subdir3fileremoved(subdir3 + "/removed");
 193   }
 194
 195   // Create file collector and add files.
 196   ScopedDir root("copy_files_root", true);
 197   std::string root_fs = root.Path.str();
 198   auto Collector = std::make_shared<TestingFileCollector>(root_fs, root_fs);
 199   auto VFS =
 200       FileCollector::createCollectorVFS(vfs::getRealFileSystem(), Collector);
 201   VFS->status(a.Path);
 202   EXPECT_TRUE(Collector->hasSeen(a.Path));
 203
 204   VFS->openFileForRead(b.Path);
 205   EXPECT_TRUE(Collector->hasSeen(b.Path));
 206
 207   VFS->status(subdir.Path);
 208   EXPECT_TRUE(Collector->hasSeen(subdir.Path));
 209
 210 #ifndef _WIN32
 211   std::error_code EC;
 212   auto It = VFS->dir_begin(subdir3.Path, EC);
 213   EXPECT_FALSE(EC);
 214   EXPECT_TRUE(Collector->hasSeen(subdir3.Path));
 215   EXPECT_TRUE(Collector->hasSeen(subdir3a.Path));
 216   EXPECT_TRUE(Collector->hasSeen(subdir3b.Path));
 217   std::string RemovedFileName = (Twine(subdir3.Path) + "/removed").str();
 218   EXPECT_FALSE(Collector->hasSeen(RemovedFileName));
 219 #endif
 220 }
 221
 222 #ifndef _WIN32
 223 TEST(FileCollectorTest, Symlinks) {
 224   // Root where the original files live.
 225   ScopedDir file_root("file_root", true);
 226
 227   // Create some files in the file root.
 228   ScopedFile a(file_root + "/aaa");
 229   ScopedFile b(file_root + "/bbb");
 230   ScopedFile c(file_root + "/ccc");
 231
 232   // Create a directory foo with file ddd.
 233   ScopedDir foo(file_root + "/foo");
 234   ScopedFile d(foo + "/ddd");
 235
 236   // Create a file eee in the foo's parent directory.
 237   ScopedFile e(foo + "/../eee");
 238
 239   // Create a symlink bar pointing to foo.
 240   ScopedLink symlink(file_root + "/foo", file_root + "/bar");
 241
 242   // Root where files are copied to.
 243   ScopedDir reproducer_root("reproducer_root", true);
 244   std::string root_fs = reproducer_root.Path.str();
 245   TestingFileCollector FileCollector(root_fs, root_fs);
 246
 247   // Add all the files to the collector.
 248   FileCollector.addFile(a.Path);
 249   FileCollector.addFile(b.Path);
 250   FileCollector.addFile(c.Path);
 251   FileCollector.addFile(d.Path);
 252   FileCollector.addFile(e.Path);
 253   FileCollector.addFile(file_root + "/bar/ddd");
 254
 255   auto mapping = FileCollector.VFSWriter.getMappings();
 256
 257   {
 258     // Make sure the common case works.
 259     std::string vpath = (file_root + "/aaa").str();
 260     std::string rpath = (reproducer_root.Path + file_root.Path + "/aaa").str();
 261     printf("%s -> %s\n", vpath.c_str(), rpath.c_str());
 262     EXPECT_THAT(mapping, testing::Contains(vfs::YAMLVFSEntry(vpath, rpath)));
 263   }
 264
 265   {
 266     // Make sure the virtual path points to the real source path.
 267     std::string vpath = (file_root + "/bar/ddd").str();
 268     std::string rpath =
 269         (reproducer_root.Path + file_root.Path + "/foo/ddd").str();
 270     printf("%s -> %s\n", vpath.c_str(), rpath.c_str());
 271     EXPECT_THAT(mapping, testing::Contains(vfs::YAMLVFSEntry(vpath, rpath)));
 272   }
 273
 274   {
 275     // Make sure that .. is removed from the source path.
 276     std::string vpath = (file_root + "/eee").str();
 277     std::string rpath = (reproducer_root.Path + file_root.Path + "/eee").str();
 278     printf("%s -> %s\n", vpath.c_str(), rpath.c_str());
 279     EXPECT_THAT(mapping, testing::Contains(vfs::YAMLVFSEntry(vpath, rpath)));
 280   }
 281 }
 282
 283 TEST(FileCollectorTest, recordVFSSymlinkAccesses) {
 284   ScopedDir file_root("dir_root", true);
 285   ScopedFile a(file_root + "/a");
 286   ScopedLink symlink(file_root + "/a", file_root + "/b");
 287
 288   // Create file collector and add files.
 289   ScopedDir root("copy_files_root", true);
 290   std::string root_fs = root.Path.str();
 291   auto Collector = std::make_shared<TestingFileCollector>(root_fs, root_fs);
 292   auto VFS =
 293       FileCollector::createCollectorVFS(vfs::getRealFileSystem(), Collector);
 294   SmallString<256> Output;
 295   VFS->getRealPath(symlink.Path, Output);
 296   EXPECT_TRUE(Collector->hasSeen(a.Path));
 297   EXPECT_TRUE(Collector->hasSeen(symlink.Path));
 298 }
 299 #endif