tests compare expected XML versus actual

Author: vinniefalco

include/mrdox/Reporter.hpp

@@ -30,7 +30,25 @@ struct Reporter
         return failed_;
     }
 
+    void test_failure()
+    {
+        failed_ = true;
+    }
+
     bool success(llvm::Error&& err);
+    bool success(std::error_code const& ec);
+
+    template<class T>
+    bool
+    success(T& t, llvm::ErrorOr<T>&& ev)
+    {
+        if(ev)
+        {
+            t = std::move(ev.get());
+            return true;
+        }
+        return false;
+    }
 
     bool
     success(

include/mrdox/XML.hpp

@@ -14,20 +14,16 @@
 
 #include <mrdox/Config.hpp>
 #include <llvm/ADT/StringRef.h>
+#include <llvm/Support/Error.h>
 #include <string>
 
 namespace clang {
 namespace mrdox {
 
-// Algorithms for rendering the corpus as XML.
-// The XML output is unaffected by the structure
-// of the input data and thus, represents a
-// canonical form.
-
-bool
-renderCodeAsXML(
+void
+renderToXMLString(
     std::string& xml,
-    llvm::StringRef cppCode,
+    Corpus const& corpus,
     Config const& cfg);
 
 } // mrdox

source/lib/Reporter.cpp

@@ -29,6 +29,18 @@ success(llvm::Error&& err)
     return false;
 }
 
+bool
+Reporter::
+success(std::error_code const& ec)
+{
+    if(! ec)
+        return true;
+    // VFALCO TODO Source file, line number, and what
+    llvm::errs() << ec.message() << "\n";
+    failed_ = true;
+    return false;
+}
+
 bool
 Reporter::
 success(

source/lib/XML.cpp

@@ -555,34 +555,20 @@ char const*
 XMLGenerator::
 Format = "xml";
 
-/** A visitor which keeps its own map of tool results.
-*/
-class TestVisitor
-    : public BasicVisitor
-{
-    TestVisitor& corpus_;
-    tooling::InMemoryToolResults results_;
-
-public:
-    TestVisitor(
-        TestVisitor& corpus,
-        Config const& cfg) noexcept
-        : BasicVisitor(cfg)
-        , corpus_(corpus)
-    {
-    }
+} // (anon)
 
-private:
-    void
-    reportResult(
-        StringRef Key,
-        StringRef Value) override
-    {
-        results_.addResult(Key, Value);
-    }
-};
+//------------------------------------------------
 
-} // (anon)
+void
+renderToXMLString(
+    std::string& xml,
+    Corpus const& corpus,
+    Config const& cfg)
+{
+    XMLGenerator G(cfg);
+    G.render(xml, corpus, cfg);
+    //return llvm::Error::success();
+}
 
 //------------------------------------------------
 

source/tests/TestAction.cpp

@@ -10,6 +10,9 @@
 
 #include "TestAction.hpp"
 #include <mrdox/Config.hpp>
+#include <mrdox/XML.hpp>
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/Path.h>
 
 namespace clang {
 namespace mrdox {
@@ -18,30 +21,46 @@ void
 TestAction::
 EndSourceFileAction()
 {
+    namespace fs = llvm::sys::fs;
+    namespace path = llvm::sys::path;
+
     Corpus corpus;
     if(! R_.success(buildIndex(corpus, results_, cfg_)))
         return;
-#if 0
-bool
-renderCodeAsXML(
-    std::string& xml,
-    llvm::StringRef cppCode,
-    Config const& cfg)
-{
-    std::unique_ptr<ASTUnit> astUnit =
-        clang::tooling::buildASTFromCodeWithArgs(cppCode, {});
-    Corpus corpus;
-    CorpusVisitor visitor(corpus, cfg);
-    visitor.HandleTranslationUnit(astUnit->getASTContext());
-    if(llvm::Error err = buildIndex(corpus, cfg))
-        return ! err;
-    bool success = XMLGenerator(cfg).render(xml, corpus, cfg);
-    // VFALCO oops, cfg.Executor->getToolResults()
-    //              holds information from the previous corpus...
-    //cfg.Executor->getToolResults()->
-    return success;
-}
-#endif
+    std::string xml;
+    renderToXMLString(xml, corpus, cfg_);
+    llvm::SmallString<256> xmlPath(this->getCurrentFile());
+    path::replace_extension(xmlPath, "xml");
+    std::error_code ec;
+    fs::file_status stat;
+    ec = fs::status(xmlPath, stat, false);
+    if(ec == std::errc::no_such_file_or_directory)
+    {
+        // create the xml file and write to it
+    }
+    else if(R_.success(ec))
+    {
+        if(stat.type() == fs::file_type::regular_file)
+        {
+            std::unique_ptr<llvm::MemoryBuffer> pb;
+            if(! R_.success(pb, llvm::MemoryBuffer::getFile(xmlPath, true)))
+                return;
+            if(xml != pb->getBuffer())
+            {
+                llvm::errs() <<
+                    "File: \"" << this->getCurrentFile() << "\" failed.\n"
+                    "Expected:\n" <<
+                    pb->getBuffer() << "\n" <<
+                    "Got:\n" <<
+                    xml << "\n";
+                R_.test_failure();
+            }
+        }
+        else
+        {
+            // VFALCO report that it is not a regular file
+        }
+    }
 }
 
 } // mrdox