r201905 - Add a VFSFromYAML class and a parser to create it
Ben Langmuir
blangmuir at apple.com
Fri Feb 21 15:39:38 PST 2014
Author: benlangmuir
Date: Fri Feb 21 17:39:37 2014
New Revision: 201905
URL: http://llvm.org/viewvc/llvm-project?rev=201905&view=rev
Log:
Add a VFSFromYAML class and a parser to create it
Provides a way to create a virtual file system using a YAML file that
supports mapping a file to a path on an 'external' file system. The
external file system will typically be the 'real' file system, but for
testing it can be changed.
A future patch will add a clang option to allow the user to specify such
a file and overlay it, but for now this code is only exercised by the
unit tests.
Differential Revision: http://llvm-reviews.chandlerc.com/D2835
Modified:
cfe/trunk/include/clang/Basic/VirtualFileSystem.h
cfe/trunk/lib/Basic/VirtualFileSystem.cpp
cfe/trunk/unittests/Basic/VirtualFileSystemTest.cpp
Modified: cfe/trunk/include/clang/Basic/VirtualFileSystem.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/VirtualFileSystem.h?rev=201905&r1=201904&r2=201905&view=diff
==============================================================================
--- cfe/trunk/include/clang/Basic/VirtualFileSystem.h (original)
+++ cfe/trunk/include/clang/Basic/VirtualFileSystem.h Fri Feb 21 17:39:37 2014
@@ -17,6 +17,7 @@
#include "llvm/ADT/IntrusiveRefCntPtr.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/SourceMgr.h"
namespace llvm {
class MemoryBuffer;
@@ -157,6 +158,17 @@ public:
OwningPtr<File> &Result) LLVM_OVERRIDE;
};
+/// \brief Get a globally unique ID for a virtual file or directory.
+llvm::sys::fs::UniqueID getNextVirtualUniqueID();
+
+/// \brief Gets a \p FileSystem for a virtual file system described in YAML
+/// format.
+///
+/// Takes ownership of \p Buffer.
+IntrusiveRefCntPtr<FileSystem>
+getVFSFromYAML(llvm::MemoryBuffer *Buffer, llvm::SourceMgr::DiagHandlerTy,
+ IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem());
+
} // end namespace vfs
} // end namespace clang
#endif // LLVM_CLANG_BASIC_VIRTUAL_FILE_SYSTEM_H
Modified: cfe/trunk/lib/Basic/VirtualFileSystem.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Basic/VirtualFileSystem.cpp?rev=201905&r1=201904&r2=201905&view=diff
==============================================================================
--- cfe/trunk/lib/Basic/VirtualFileSystem.cpp (original)
+++ cfe/trunk/lib/Basic/VirtualFileSystem.cpp Fri Feb 21 17:39:37 2014
@@ -10,10 +10,14 @@
//===----------------------------------------------------------------------===//
#include "clang/Basic/VirtualFileSystem.h"
+#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/OwningPtr.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Atomic.h"
#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/Path.h"
+#include "llvm/Support/YAMLParser.h"
using namespace clang;
using namespace clang::vfs;
@@ -83,6 +87,7 @@ class RealFile : public File {
RealFile(int FD) : FD(FD) {
assert(FD >= 0 && "Invalid or inactive file descriptor");
}
+
public:
~RealFile();
ErrorOr<Status> status() LLVM_OVERRIDE;
@@ -91,9 +96,7 @@ public:
bool RequiresNullTerminator = true) LLVM_OVERRIDE;
error_code close() LLVM_OVERRIDE;
};
-RealFile::~RealFile() {
- close();
-}
+RealFile::~RealFile() { close(); }
ErrorOr<Status> RealFile::status() {
assert(FD != -1 && "cannot stat closed file");
@@ -191,3 +194,572 @@ error_code OverlayFileSystem::openFileFo
}
return error_code(errc::no_such_file_or_directory, system_category());
}
+
+//===-----------------------------------------------------------------------===/
+// VFSFromYAML implementation
+//===-----------------------------------------------------------------------===/
+
+// Allow DenseMap<StringRef, ...>. This is useful below because we know all the
+// strings are literals and will outlive the map, and there is no reason to
+// store them.
+namespace llvm {
+ template<>
+ struct DenseMapInfo<StringRef> {
+ // This assumes that "" will never be a valid key.
+ static inline StringRef getEmptyKey() { return StringRef(""); }
+ static inline StringRef getTombstoneKey() { return StringRef(); }
+ static unsigned getHashValue(StringRef Val) { return HashString(Val); }
+ static bool isEqual(StringRef LHS, StringRef RHS) { return LHS == RHS; }
+ };
+}
+
+namespace {
+
+enum EntryKind {
+ EK_Directory,
+ EK_File
+};
+
+/// \brief A single file or directory in the VFS.
+class Entry {
+ EntryKind Kind;
+ std::string Name;
+
+public:
+ virtual ~Entry();
+#if LLVM_HAS_RVALUE_REFERENCES
+ Entry(EntryKind K, std::string Name) : Kind(K), Name(std::move(Name)) {}
+#endif
+ Entry(EntryKind K, StringRef Name) : Kind(K), Name(Name) {}
+ StringRef getName() const { return Name; }
+ EntryKind getKind() const { return Kind; }
+};
+
+class DirectoryEntry : public Entry {
+ std::vector<Entry *> Contents;
+ Status S;
+
+public:
+ virtual ~DirectoryEntry();
+#if LLVM_HAS_RVALUE_REFERENCES
+ DirectoryEntry(std::string Name, std::vector<Entry *> Contents, Status S)
+ : Entry(EK_Directory, std::move(Name)), Contents(std::move(Contents)),
+ S(std::move(S)) {}
+#endif
+ DirectoryEntry(StringRef Name, ArrayRef<Entry *> Contents, const Status &S)
+ : Entry(EK_Directory, Name), Contents(Contents), S(S) {}
+ Status getStatus() { return S; }
+ typedef std::vector<Entry *>::iterator iterator;
+ iterator contents_begin() { return Contents.begin(); }
+ iterator contents_end() { return Contents.end(); }
+ static bool classof(const Entry *E) { return E->getKind() == EK_Directory; }
+};
+
+class FileEntry : public Entry {
+ std::string ExternalContentsPath;
+
+public:
+#if LLVM_HAS_RVALUE_REFERENCES
+ FileEntry(std::string Name, std::string ExternalContentsPath)
+ : Entry(EK_File, std::move(Name)),
+ ExternalContentsPath(std::move(ExternalContentsPath)) {}
+#endif
+ FileEntry(StringRef Name, StringRef ExternalContentsPath)
+ : Entry(EK_File, Name), ExternalContentsPath(ExternalContentsPath) {}
+ StringRef getExternalContentsPath() const { return ExternalContentsPath; }
+ static bool classof(const Entry *E) { return E->getKind() == EK_File; }
+};
+
+/// \brief A virtual file system parsed from a YAML file.
+///
+/// Currently, this class allows creating virtual directories and mapping
+/// virtual file paths to existing external files, available in \c ExternalFS.
+///
+/// The basic structure of the parsed file is:
+/// \verbatim
+/// {
+/// 'version': <version number>,
+/// <optional configuration>
+/// 'roots': [
+/// <directory entries>
+/// ]
+/// }
+/// \endverbatim
+///
+/// All configuration options are optional.
+/// 'case-sensitive': <boolean, default=true>
+///
+/// Virtual directories are represented as
+/// \verbatim
+/// {
+/// 'type': 'directory',
+/// 'name': <string>,
+/// 'contents': [ <file or directory entries> ]
+/// }
+/// \endverbatim
+///
+/// The default attributes for virtual directories are:
+/// \verbatim
+/// MTime = now() when created
+/// Perms = 0777
+/// User = Group = 0
+/// Size = 0
+/// UniqueID = unspecified unique value
+/// \endverbatim
+///
+/// Re-mapped files are represented as
+/// \verbatim
+/// {
+/// 'type': 'file',
+/// 'name': <string>,
+/// 'external-contents': <path to external file>)
+/// }
+/// \endverbatim
+///
+/// and inherit their attributes from the external contents.
+///
+/// In both cases, the 'name' field must be a single path component (containing
+/// no separators).
+class VFSFromYAML : public vfs::FileSystem {
+ std::vector<Entry *> Roots; ///< The root(s) of the virtual file system.
+ /// \brief The file system to use for external references.
+ IntrusiveRefCntPtr<FileSystem> ExternalFS;
+
+ /// @name Configuration
+ /// @{
+
+ /// \brief Whether to perform case-sensitive comparisons.
+ ///
+ /// Currently, case-insensitive matching only works correctly with ASCII.
+ bool CaseSensitive; ///< Whether to perform case-sensitive comparisons.
+ /// @}
+
+ friend class VFSFromYAMLParser;
+
+private:
+ VFSFromYAML(IntrusiveRefCntPtr<FileSystem> ExternalFS)
+ : ExternalFS(ExternalFS), CaseSensitive(true) {}
+
+ /// \brief Looks up \p Path in \c Roots.
+ ErrorOr<Entry *> lookupPath(const Twine &Path);
+
+ /// \brief Looks up the path <tt>[Start, End)</tt> in \p From, possibly
+ /// recursing into the contents of \p From if it is a directory.
+ ErrorOr<Entry *> lookupPath(sys::path::const_iterator Start,
+ sys::path::const_iterator End, Entry *From);
+
+public:
+ ~VFSFromYAML();
+
+ /// \brief Parses \p Buffer, which is expected to be in YAML format and
+ /// returns a virtual file system representing its contents.
+ ///
+ /// Takes ownership of \p Buffer.
+ static VFSFromYAML *create(MemoryBuffer *Buffer,
+ SourceMgr::DiagHandlerTy DiagHandler,
+ IntrusiveRefCntPtr<FileSystem> ExternalFS);
+
+ ErrorOr<Status> status(const Twine &Path) LLVM_OVERRIDE;
+ error_code openFileForRead(const Twine &Path,
+ OwningPtr<File> &Result) LLVM_OVERRIDE;
+};
+
+/// \brief A helper class to hold the common YAML parsing state.
+class VFSFromYAMLParser {
+ yaml::Stream &Stream;
+
+ void error(yaml::Node *N, const Twine &Msg) {
+ Stream.printError(N, Msg);
+ }
+
+ // false on error
+ bool parseScalarString(yaml::Node *N, StringRef &Result,
+ SmallVectorImpl<char> &Storage) {
+ yaml::ScalarNode *S = dyn_cast<yaml::ScalarNode>(N);
+ if (!S) {
+ error(N, "expected string");
+ return false;
+ }
+ Result = S->getValue(Storage);
+ return true;
+ }
+
+ // false on error
+ bool parseScalarBool(yaml::Node *N, bool &Result) {
+ SmallString<5> Storage;
+ StringRef Value;
+ if (!parseScalarString(N, Value, Storage))
+ return false;
+
+ if (Value.equals_lower("true") || Value.equals_lower("on") ||
+ Value.equals_lower("yes") || Value == "1") {
+ Result = true;
+ return true;
+ } else if (Value.equals_lower("false") || Value.equals_lower("off") ||
+ Value.equals_lower("no") || Value == "0") {
+ Result = false;
+ return true;
+ }
+
+ error(N, "expected boolean value");
+ return false;
+ }
+
+ struct KeyStatus {
+ KeyStatus(bool Required=false) : Required(Required), Seen(false) {}
+ bool Required;
+ bool Seen;
+ };
+ typedef std::pair<StringRef, KeyStatus> KeyStatusPair;
+
+ // false on error
+ bool checkDuplicateOrUnknownKey(yaml::Node *KeyNode, StringRef Key,
+ DenseMap<StringRef, KeyStatus> &Keys) {
+ if (!Keys.count(Key)) {
+ error(KeyNode, "unknown key");
+ return false;
+ }
+ KeyStatus &S = Keys[Key];
+ if (S.Seen) {
+ error(KeyNode, Twine("duplicate key '") + Key + "'");
+ return false;
+ }
+ S.Seen = true;
+ return true;
+ }
+
+ // false on error
+ bool checkMissingKeys(yaml::Node *Obj, DenseMap<StringRef, KeyStatus> &Keys) {
+ for (DenseMap<StringRef, KeyStatus>::iterator I = Keys.begin(),
+ E = Keys.end();
+ I != E; ++I) {
+ if (I->second.Required && !I->second.Seen) {
+ error(Obj, Twine("missing key '") + I->first + "'");
+ return false;
+ }
+ }
+ return true;
+ }
+
+ Entry *parseEntry(yaml::Node *N) {
+ yaml::MappingNode *M = dyn_cast<yaml::MappingNode>(N);
+ if (!M) {
+ error(N, "expected mapping node for file or directory entry");
+ return NULL;
+ }
+
+ KeyStatusPair Fields[] = {
+ KeyStatusPair("name", true),
+ KeyStatusPair("type", true),
+ KeyStatusPair("contents", false),
+ KeyStatusPair("external-contents", false)
+ };
+
+ DenseMap<StringRef, KeyStatus> Keys(
+ &Fields[0], Fields + sizeof(Fields)/sizeof(Fields[0]));
+
+ bool HasContents = false; // external or otherwise
+ std::vector<Entry *> EntryArrayContents;
+ std::string ExternalContentsPath;
+ std::string Name;
+ EntryKind Kind;
+
+ for (yaml::MappingNode::iterator I = M->begin(), E = M->end(); I != E;
+ ++I) {
+ StringRef Key;
+ // Reuse the buffer for key and value, since we don't look at key after
+ // parsing value.
+ SmallString<256> Buffer;
+ if (!parseScalarString(I->getKey(), Key, Buffer))
+ return NULL;
+
+ if (!checkDuplicateOrUnknownKey(I->getKey(), Key, Keys))
+ return NULL;
+
+ StringRef Value;
+ if (Key == "name") {
+ if (!parseScalarString(I->getValue(), Value, Buffer))
+ return NULL;
+ Name = Value;
+ if (sys::path::has_parent_path(Name)) {
+ error(I->getValue(), "unexpected path separator in name");
+ return NULL;
+ }
+ } else if (Key == "type") {
+ if (!parseScalarString(I->getValue(), Value, Buffer))
+ return NULL;
+ if (Value == "file")
+ Kind = EK_File;
+ else if (Value == "directory")
+ Kind = EK_Directory;
+ else {
+ error(I->getValue(), "unknown value for 'type'");
+ return NULL;
+ }
+ } else if (Key == "contents") {
+ if (HasContents) {
+ error(I->getKey(),
+ "entry already has 'contents' or 'external-contents'");
+ return NULL;
+ }
+ HasContents = true;
+ yaml::SequenceNode *Contents =
+ dyn_cast<yaml::SequenceNode>(I->getValue());
+ if (!Contents) {
+ // FIXME: this is only for directories, what about files?
+ error(I->getValue(), "expected array");
+ return NULL;
+ }
+
+ for (yaml::SequenceNode::iterator I = Contents->begin(),
+ E = Contents->end();
+ I != E; ++I) {
+ if (Entry *E = parseEntry(&*I))
+ EntryArrayContents.push_back(E);
+ else
+ return NULL;
+ }
+ } else if (Key == "external-contents") {
+ if (HasContents) {
+ error(I->getKey(),
+ "entry already has 'contents' or 'external-contents'");
+ return NULL;
+ }
+ HasContents = true;
+ if (!parseScalarString(I->getValue(), Value, Buffer))
+ return NULL;
+ ExternalContentsPath = Value;
+ } else {
+ llvm_unreachable("key missing from Keys");
+ }
+ }
+
+ if (Stream.failed())
+ return NULL;
+
+ // check for missing keys
+ if (!HasContents) {
+ error(N, "missing key 'contents' or 'external-contents'");
+ return NULL;
+ }
+ if (!checkMissingKeys(N, Keys))
+ return NULL;
+
+ switch (Kind) {
+ case EK_File:
+ return new FileEntry(llvm_move(Name), llvm_move(ExternalContentsPath));
+ case EK_Directory:
+ return new DirectoryEntry(
+ llvm_move(Name), llvm_move(EntryArrayContents),
+ Status("", "", getNextVirtualUniqueID(), sys::TimeValue::now(), 0, 0,
+ 0, file_type::directory_file, sys::fs::all_all));
+ }
+ }
+
+public:
+ VFSFromYAMLParser(yaml::Stream &S) : Stream(S) {}
+
+ // false on error
+ bool parse(yaml::Node *Root, VFSFromYAML *FS) {
+ yaml::MappingNode *Top = dyn_cast<yaml::MappingNode>(Root);
+ if (!Top) {
+ error(Root, "expected mapping node");
+ return false;
+ }
+
+ KeyStatusPair Fields[] = {
+ KeyStatusPair("version", true),
+ KeyStatusPair("case-sensitive", false),
+ KeyStatusPair("roots", true),
+ };
+
+ DenseMap<StringRef, KeyStatus> Keys(
+ &Fields[0], Fields + sizeof(Fields)/sizeof(Fields[0]));
+
+ // Parse configuration and 'roots'
+ for (yaml::MappingNode::iterator I = Top->begin(), E = Top->end(); I != E;
+ ++I) {
+ SmallString<10> KeyBuffer;
+ StringRef Key;
+ if (!parseScalarString(I->getKey(), Key, KeyBuffer))
+ return false;
+
+ if (!checkDuplicateOrUnknownKey(I->getKey(), Key, Keys))
+ return false;
+
+ if (Key == "roots") {
+ yaml::SequenceNode *Roots = dyn_cast<yaml::SequenceNode>(I->getValue());
+ if (!Roots) {
+ error(I->getValue(), "expected array");
+ return false;
+ }
+
+ for (yaml::SequenceNode::iterator I = Roots->begin(), E = Roots->end();
+ I != E; ++I) {
+ if (Entry *E = parseEntry(&*I))
+ FS->Roots.push_back(E);
+ else
+ return false;
+ }
+ } else if (Key == "version") {
+ StringRef VersionString;
+ SmallString<4> Storage;
+ if (!parseScalarString(I->getValue(), VersionString, Storage))
+ return false;
+ int Version;
+ if (VersionString.getAsInteger<int>(10, Version)) {
+ error(I->getValue(), "expected integer");
+ return false;
+ }
+ if (Version < 0) {
+ error(I->getValue(), "invalid version number");
+ return false;
+ }
+ if (Version != 0) {
+ error(I->getValue(), "version mismatch, expected 0");
+ return false;
+ }
+ } else if (Key == "case-sensitive") {
+ if (!parseScalarBool(I->getValue(), FS->CaseSensitive))
+ return false;
+ } else {
+ llvm_unreachable("key missing from Keys");
+ }
+ }
+
+ if (Stream.failed())
+ return false;
+
+ if (!checkMissingKeys(Top, Keys))
+ return false;
+ return true;
+ }
+};
+} // end of anonymous namespace
+
+Entry::~Entry() {}
+DirectoryEntry::~DirectoryEntry() { llvm::DeleteContainerPointers(Contents); }
+
+VFSFromYAML::~VFSFromYAML() { llvm::DeleteContainerPointers(Roots); }
+
+VFSFromYAML *VFSFromYAML::create(MemoryBuffer *Buffer,
+ SourceMgr::DiagHandlerTy DiagHandler,
+ IntrusiveRefCntPtr<FileSystem> ExternalFS) {
+
+ SourceMgr SM;
+ yaml::Stream Stream(Buffer, SM);
+
+ SM.setDiagHandler(DiagHandler);
+ yaml::document_iterator DI = Stream.begin();
+ yaml::Node *Root = DI->getRoot();
+ if (DI == Stream.end() || !Root) {
+ SM.PrintMessage(SMLoc(), SourceMgr::DK_Error, "expected root node");
+ return NULL;
+ }
+
+ VFSFromYAMLParser P(Stream);
+
+ OwningPtr<VFSFromYAML> FS(new VFSFromYAML(ExternalFS));
+ if (!P.parse(Root, FS.get()))
+ return NULL;
+
+ return FS.take();
+}
+
+ErrorOr<Entry *> VFSFromYAML::lookupPath(const Twine &Path_) {
+ SmallVector<char, 256> Storage;
+ StringRef Path = Path_.toNullTerminatedStringRef(Storage);
+
+ if (Path.empty())
+ return error_code(errc::invalid_argument, system_category());
+
+ sys::path::const_iterator Start = sys::path::begin(Path);
+ sys::path::const_iterator End = sys::path::end(Path);
+ for (std::vector<Entry *>::iterator I = Roots.begin(), E = Roots.end();
+ I != E; ++I) {
+ ErrorOr<Entry *> Result = lookupPath(Start, End, *I);
+ if (Result || Result.getError() != errc::no_such_file_or_directory)
+ return Result;
+ }
+ return error_code(errc::no_such_file_or_directory, system_category());
+}
+
+ErrorOr<Entry *> VFSFromYAML::lookupPath(sys::path::const_iterator Start,
+ sys::path::const_iterator End,
+ Entry *From) {
+ // FIXME: handle . and ..
+ if (CaseSensitive ? !Start->equals(From->getName())
+ : !Start->equals_lower(From->getName()))
+ // failure to match
+ return error_code(errc::no_such_file_or_directory, system_category());
+
+ ++Start;
+
+ if (Start == End) {
+ // Match!
+ return From;
+ }
+
+ DirectoryEntry *DE = dyn_cast<DirectoryEntry>(From);
+ if (!DE)
+ return error_code(errc::not_a_directory, system_category());
+
+ for (DirectoryEntry::iterator I = DE->contents_begin(),
+ E = DE->contents_end();
+ I != E; ++I) {
+ ErrorOr<Entry *> Result = lookupPath(Start, End, *I);
+ if (Result || Result.getError() != errc::no_such_file_or_directory)
+ return Result;
+ }
+ return error_code(errc::no_such_file_or_directory, system_category());
+}
+
+ErrorOr<Status> VFSFromYAML::status(const Twine &Path) {
+ ErrorOr<Entry *> Result = lookupPath(Path);
+ if (!Result)
+ return Result.getError();
+
+ std::string PathStr(Path.str());
+ if (FileEntry *F = dyn_cast<FileEntry>(*Result)) {
+ ErrorOr<Status> S = ExternalFS->status(F->getExternalContentsPath());
+ if (S) {
+ assert(S->getName() == S->getExternalName() &&
+ S->getName() == F->getExternalContentsPath());
+ S->setName(PathStr);
+ }
+ return S;
+ } else { // directory
+ DirectoryEntry *DE = cast<DirectoryEntry>(*Result);
+ Status S = DE->getStatus();
+ S.setName(PathStr);
+ S.setExternalName(PathStr);
+ return S;
+ }
+}
+
+error_code VFSFromYAML::openFileForRead(const Twine &Path,
+ OwningPtr<vfs::File> &Result) {
+ ErrorOr<Entry *> E = lookupPath(Path);
+ if (!E)
+ return E.getError();
+
+ FileEntry *F = dyn_cast<FileEntry>(*E);
+ if (!F) // FIXME: errc::not_a_file?
+ return error_code(errc::invalid_argument, system_category());
+
+ return ExternalFS->openFileForRead(Path, Result);
+}
+
+IntrusiveRefCntPtr<FileSystem>
+vfs::getVFSFromYAML(MemoryBuffer *Buffer, SourceMgr::DiagHandlerTy DiagHandler,
+ IntrusiveRefCntPtr<FileSystem> ExternalFS) {
+ return VFSFromYAML::create(Buffer, DiagHandler, ExternalFS);
+}
+
+UniqueID vfs::getNextVirtualUniqueID() {
+ static volatile sys::cas_flag UID = 0;
+ sys::cas_flag ID = llvm::sys::AtomicIncrement(&UID);
+ // The following assumes that uint64_t max will never collide with a real
+ // dev_t value from the OS.
+ return UniqueID(std::numeric_limits<uint64_t>::max(), ID);
+}
Modified: cfe/trunk/unittests/Basic/VirtualFileSystemTest.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/Basic/VirtualFileSystemTest.cpp?rev=201905&r1=201904&r2=201905&view=diff
==============================================================================
--- cfe/trunk/unittests/Basic/VirtualFileSystemTest.cpp (original)
+++ cfe/trunk/unittests/Basic/VirtualFileSystemTest.cpp Fri Feb 21 17:39:37 2014
@@ -8,7 +8,9 @@
//===----------------------------------------------------------------------===//
#include "clang/Basic/VirtualFileSystem.h"
+#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
+#include "llvm/Support/SourceMgr.h"
#include "gtest/gtest.h"
#include <map>
using namespace clang;
@@ -31,7 +33,7 @@ public:
ErrorOr<vfs::Status> status(const Twine &Path) {
std::map<std::string, vfs::Status>::iterator I =
- FilesAndDirs.find(Path.str());
+ FilesAndDirs.find(Path.str());
if (I == FilesAndDirs.end())
return error_code(errc::no_such_file_or_directory, posix_category());
return I->second;
@@ -50,13 +52,13 @@ public:
FilesAndDirs[Path] = Status;
}
- void addRegularFile(StringRef Path, sys::fs::perms Perms=sys::fs::all_all) {
+ void addRegularFile(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
vfs::Status S(Path, Path, UniqueID(FSID, FileID++), sys::TimeValue::now(),
0, 0, 1024, sys::fs::file_type::regular_file, Perms);
addEntry(Path, S);
}
- void addDirectory(StringRef Path, sys::fs::perms Perms=sys::fs::all_all) {
+ void addDirectory(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
vfs::Status S(Path, Path, UniqueID(FSID, FileID++), sys::TimeValue::now(),
0, 0, 0, sys::fs::file_type::directory_file, Perms);
addEntry(Path, S);
@@ -70,7 +72,7 @@ public:
};
} // end anonymous namespace
-TEST(VirtualFileSystemTest, statusQueries) {
+TEST(VirtualFileSystemTest, StatusQueries) {
IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
ErrorOr<vfs::Status> Status((error_code()));
@@ -110,7 +112,7 @@ TEST(VirtualFileSystemTest, statusQuerie
EXPECT_FALSE(Status->equivalent(*Status2));
}
-TEST(VirtualFileSystemTest, baseOnlyOverlay) {
+TEST(VirtualFileSystemTest, BaseOnlyOverlay) {
IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
ErrorOr<vfs::Status> Status((error_code()));
EXPECT_FALSE(Status = D->status("/foo"));
@@ -128,17 +130,18 @@ TEST(VirtualFileSystemTest, baseOnlyOver
EXPECT_TRUE(Status->equivalent(*Status2));
}
-TEST(VirtualFileSystemTest, overlayFiles) {
+TEST(VirtualFileSystemTest, OverlayFiles) {
IntrusiveRefCntPtr<DummyFileSystem> Base(new DummyFileSystem());
IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
IntrusiveRefCntPtr<DummyFileSystem> Top(new DummyFileSystem());
- IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(new vfs::OverlayFileSystem(Base));
+ IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+ new vfs::OverlayFileSystem(Base));
O->pushOverlay(Middle);
O->pushOverlay(Top);
ErrorOr<vfs::Status> Status1((error_code())), Status2((error_code())),
- Status3((error_code())), StatusB((error_code())),
- StatusM((error_code())), StatusT((error_code()));
+ Status3((error_code())), StatusB((error_code())), StatusM((error_code())),
+ StatusT((error_code()));
Base->addRegularFile("/foo");
StatusB = Base->status("/foo");
@@ -165,11 +168,11 @@ TEST(VirtualFileSystemTest, overlayFiles
EXPECT_FALSE(Status1->equivalent(*Status3));
}
-TEST(VirtualFileSystemTest, overlayDirsNonMerged) {
+TEST(VirtualFileSystemTest, OverlayDirsNonMerged) {
IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
- IntrusiveRefCntPtr<vfs::OverlayFileSystem>
- O(new vfs::OverlayFileSystem(Lower));
+ IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+ new vfs::OverlayFileSystem(Lower));
O->pushOverlay(Upper);
Lower->addDirectory("/lower-only");
@@ -189,12 +192,12 @@ TEST(VirtualFileSystemTest, overlayDirsN
EXPECT_TRUE(Status1->equivalent(*Status2));
}
-TEST(VirtualFileSystemTest, mergedDirPermissions) {
+TEST(VirtualFileSystemTest, MergedDirPermissions) {
// merged directories get the permissions of the upper dir
IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
- IntrusiveRefCntPtr<vfs::OverlayFileSystem>
- O(new vfs::OverlayFileSystem(Lower));
+ IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+ new vfs::OverlayFileSystem(Lower));
O->pushOverlay(Upper);
ErrorOr<vfs::Status> Status((error_code()));
@@ -214,3 +217,248 @@ TEST(VirtualFileSystemTest, mergedDirPer
ASSERT_EQ(errc::success, Status.getError());
EXPECT_EQ(0200, Status->getPermissions());
}
+
+static int NumDiagnostics = 0;
+static void CountingDiagHandler(const SMDiagnostic &, void *) {
+ ++NumDiagnostics;
+}
+
+static IntrusiveRefCntPtr<vfs::FileSystem>
+getFromYAMLRawString(StringRef Content,
+ IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS) {
+ MemoryBuffer *Buffer = MemoryBuffer::getMemBuffer(Content);
+ return getVFSFromYAML(Buffer, CountingDiagHandler, ExternalFS);
+}
+
+static IntrusiveRefCntPtr<vfs::FileSystem> getFromYAMLString(
+ StringRef Content,
+ IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS = new DummyFileSystem()) {
+ std::string VersionPlusContent("{\n 'version':0,\n");
+ VersionPlusContent += Content.slice(Content.find('{') + 1, StringRef::npos);
+ return getFromYAMLRawString(VersionPlusContent, ExternalFS);
+}
+
+TEST(VirtualFileSystemTest, BasicVFSFromYAML) {
+ NumDiagnostics = 0;
+ IntrusiveRefCntPtr<vfs::FileSystem> FS;
+ FS = getFromYAMLString("");
+ EXPECT_EQ(NULL, FS.getPtr());
+ FS = getFromYAMLString("[]");
+ EXPECT_EQ(NULL, FS.getPtr());
+ FS = getFromYAMLString("'string'");
+ EXPECT_EQ(NULL, FS.getPtr());
+ EXPECT_EQ(3, NumDiagnostics);
+}
+
+TEST(VirtualFileSystemTest, MappedFiles) {
+ NumDiagnostics = 0;
+ IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+ Lower->addRegularFile("/foo/bar/a");
+ IntrusiveRefCntPtr<vfs::FileSystem> FS =
+ getFromYAMLString("{ 'roots': [\n"
+ "{\n"
+ " 'type': 'directory',\n"
+ " 'name': '/',\n"
+ " 'contents': [ {\n"
+ " 'type': 'file',\n"
+ " 'name': 'file1',\n"
+ " 'external-contents': '/foo/bar/a'\n"
+ " },\n"
+ " {\n"
+ " 'type': 'file',\n"
+ " 'name': 'file2',\n"
+ " 'external-contents': '/foo/b'\n"
+ " }\n"
+ " ]\n"
+ "}\n"
+ "]\n"
+ "}",
+ Lower);
+ ASSERT_TRUE(FS.getPtr());
+
+ IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+ new vfs::OverlayFileSystem(Lower));
+ O->pushOverlay(FS);
+
+ // file
+ ErrorOr<vfs::Status> S = O->status("/file1");
+ ASSERT_EQ(errc::success, S.getError());
+ EXPECT_EQ("/file1", S->getName());
+ EXPECT_EQ("/foo/bar/a", S->getExternalName());
+
+ ErrorOr<vfs::Status> SLower = O->status("/foo/bar/a");
+ EXPECT_EQ("/foo/bar/a", SLower->getName());
+ EXPECT_TRUE(S->equivalent(*SLower));
+
+ // directory
+ S = O->status("/");
+ ASSERT_EQ(errc::success, S.getError());
+ EXPECT_TRUE(S->isDirectory());
+ EXPECT_TRUE(S->equivalent(*O->status("/"))); // non-volatile UniqueID
+
+ // broken mapping
+ EXPECT_EQ(errc::no_such_file_or_directory, O->status("/file2").getError());
+ EXPECT_EQ(0, NumDiagnostics);
+}
+
+TEST(VirtualFileSystemTest, CaseInsensitive) {
+ NumDiagnostics = 0;
+ IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+ Lower->addRegularFile("/foo/bar/a");
+ IntrusiveRefCntPtr<vfs::FileSystem> FS =
+ getFromYAMLString("{ 'case-sensitive': 'false',\n"
+ " 'roots': [\n"
+ "{\n"
+ " 'type': 'directory',\n"
+ " 'name': '/',\n"
+ " 'contents': [ {\n"
+ " 'type': 'file',\n"
+ " 'name': 'XX',\n"
+ " 'external-contents': '/foo/bar/a'\n"
+ " }\n"
+ " ]\n"
+ "}]}",
+ Lower);
+ ASSERT_TRUE(FS.getPtr());
+
+ IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+ new vfs::OverlayFileSystem(Lower));
+ O->pushOverlay(FS);
+
+ ErrorOr<vfs::Status> S = O->status("/XX");
+ ASSERT_EQ(errc::success, S.getError());
+
+ ErrorOr<vfs::Status> SS = O->status("/xx");
+ ASSERT_EQ(errc::success, SS.getError());
+ EXPECT_TRUE(S->equivalent(*SS));
+ SS = O->status("/xX");
+ EXPECT_TRUE(S->equivalent(*SS));
+ SS = O->status("/Xx");
+ EXPECT_TRUE(S->equivalent(*SS));
+ EXPECT_EQ(0, NumDiagnostics);
+}
+
+TEST(VirtualFileSystemTest, CaseSensitive) {
+ NumDiagnostics = 0;
+ IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+ Lower->addRegularFile("/foo/bar/a");
+ IntrusiveRefCntPtr<vfs::FileSystem> FS =
+ getFromYAMLString("{ 'case-sensitive': 'true',\n"
+ " 'roots': [\n"
+ "{\n"
+ " 'type': 'directory',\n"
+ " 'name': '/',\n"
+ " 'contents': [ {\n"
+ " 'type': 'file',\n"
+ " 'name': 'XX',\n"
+ " 'external-contents': '/foo/bar/a'\n"
+ " }\n"
+ " ]\n"
+ "}]}",
+ Lower);
+ ASSERT_TRUE(FS.getPtr());
+
+ IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
+ new vfs::OverlayFileSystem(Lower));
+ O->pushOverlay(FS);
+
+ ErrorOr<vfs::Status> SS = O->status("/xx");
+ EXPECT_EQ(errc::no_such_file_or_directory, SS.getError());
+ SS = O->status("/xX");
+ EXPECT_EQ(errc::no_such_file_or_directory, SS.getError());
+ SS = O->status("/Xx");
+ EXPECT_EQ(errc::no_such_file_or_directory, SS.getError());
+ EXPECT_EQ(0, NumDiagnostics);
+}
+
+TEST(VirtualFileSystemTest, IllegalVFSFile) {
+ NumDiagnostics = 0;
+ IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
+
+ // invalid YAML at top-level
+ IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString("{]", Lower);
+ EXPECT_FALSE(FS.getPtr());
+ // invalid YAML in roots
+ FS = getFromYAMLString("{ 'roots':[}", Lower);
+ // invalid YAML in directory
+ FS = getFromYAMLString(
+ "{ 'roots':[ { 'name': 'foo', 'type': 'directory', 'contents': [}",
+ Lower);
+ EXPECT_FALSE(FS.getPtr());
+
+ // invalid configuration
+ FS = getFromYAMLString("{ 'knobular': 'true', 'roots':[] }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString("{ 'case-sensitive': 'maybe', 'roots':[] }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+
+ // invalid roots
+ FS = getFromYAMLString("{ 'roots':'' }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString("{ 'roots':{} }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+
+ // invalid entries
+ FS = getFromYAMLString(
+ "{ 'roots':[ { 'type': 'other', 'name': 'me', 'contents': '' }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': [], "
+ "'external-contents': 'other' }",
+ Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString(
+ "{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': [] }",
+ Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString(
+ "{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': {} }",
+ Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString(
+ "{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': {} }",
+ Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString(
+ "{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': '' }",
+ Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString(
+ "{ 'roots':[ { 'thingy': 'directory', 'name': 'me', 'contents': [] }",
+ Lower);
+ EXPECT_FALSE(FS.getPtr());
+
+ // missing mandatory fields
+ FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': 'me' }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString(
+ "{ 'roots':[ { 'type': 'file', 'external-contents': 'other' }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString("{ 'roots':[ { 'name': 'me', 'contents': [] }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+
+ // duplicate keys
+ FS = getFromYAMLString("{ 'roots':[], 'roots':[] }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLString(
+ "{ 'case-sensitive':'true', 'case-sensitive':'true', 'roots':[] }",
+ Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS =
+ getFromYAMLString("{ 'roots':[{'name':'me', 'name':'you', 'type':'file', "
+ "'external-contents':'blah' } ] }",
+ Lower);
+ EXPECT_FALSE(FS.getPtr());
+
+ // missing version
+ FS = getFromYAMLRawString("{ 'roots':[] }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+
+ // bad version number
+ FS = getFromYAMLRawString("{ 'version':'foo', 'roots':[] }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLRawString("{ 'version':-1, 'roots':[] }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+ FS = getFromYAMLRawString("{ 'version':100000, 'roots':[] }", Lower);
+ EXPECT_FALSE(FS.getPtr());
+ EXPECT_EQ(24, NumDiagnostics);
+}
More information about the cfe-commits
mailing list