Don't use macro hacks, instead write test generators directly

Author: tsarn

src/test.cpp

@@ -45,44 +45,61 @@ std::pair<PrimitiveInteger, PrimitiveInteger> Type::getRange() const {
     return { 0, 0 };
 }
 
-void Test::print(std::ostream &ss) const {
-    ss << "TEST(" << signature.name << "Test, " << name << ") {\n";
-    ss << "    ASSERT_EQ(";
-    printFunctionCall(ss);
-    ss << ", " << signature.returnType->printValue(resultMacroName()) << ");\n";
-    ss << "}\n";
-}
+std::string quote(const std::string& s) {
+    std::stringstream ss;
+
+    ss << '"';
+    bool inEscape = false;
+
+    for (char c : s) {
+        if (c == '\n') ss << "\\n";
+        else if (c == '\t') ss << "\\t";
+        else if (c == '"') ss << "\\\"";
+        else if (c == '\0') {
+            inEscape = !inEscape;
+            if (inEscape) {
+                ss << "\" << ";
+            } else {
+                ss << " << \"";
+            }
+        } else ss << c;
+    }
+
+    ss << '"';
 
-std::string Test::resultMacroName() const {
-    return "FUZZ_TEST_" + name;
+    return ss.str();
 }
 
-void Test::printPreludeGenerator(std::ostream &ss) const {
-    auto macro = resultMacroName();
-    auto var = macro + "_result";
-    ss << "auto " << var << " = ";
-    printFunctionCall(ss);
-    ss << ";\n";
+std::string Test::print() const {
+    std::stringstream ss;
+    auto call = printFunctionCall();
+    ss << "TEST(" << signature.name << "Test, " << name << ") {\n";
+    ss << "    ASSERT_EQ(" << call;
+    ss << ", " << signature.returnType->printValue('\0' + call + '\0') << ");\n";
+    ss << "}\n";
+    return ss.str();
+}
 
-    ss << "std::cout << \"#define " << macro << " \" << " << var << " << \"\\n\"\n";
+std::string Test::printGenerator() const {
+    return "std::cout << " + quote(print()) + ";\n";
 }
 
-void Test::printFunctionCall(std::ostream &ss) const {
-    ss << signature.name << "(";
+std::string Test::printFunctionCall() const {
+    std::string res;
+    res += signature.name + "(";
 
     bool first = true;
 
     for (const auto &arg : arguments) {
         if (!first) {
-            ss << ", ";
+            res += ", ";
         }
-
-        ss << arg.print();
-
+        res += arg.print();
         first = false;
     }
 
-    ss << ")";
+    res += ")";
+    return res;
 }
 
 std::string printPrimitiveType(PrimitiveType type) {
@@ -112,3 +129,21 @@ Type::ptr primitiveType(PrimitiveType type, PrimitiveInteger min, PrimitiveInteg
 Type::ptr pointerTo(Type::ptr type) {
     return std::make_shared<Type>(Type { PointerTo { std::move(type) } } );
 }
+
+std::string TestSignature::print() const {
+    std::string res = returnType->print() + " " + name;
+    res += "(";
+
+    bool first = true;
+
+    for (const auto &type : parameterTypes) {
+        if (!first) {
+            res += ", ";
+        }
+        first = false;
+        res += type->print();
+    }
+
+    res += ");\n";
+    return res;
+}

src/test.h

@@ -50,6 +50,8 @@ struct TestSignature {
     std::string name;
     std::vector<Type::ptr> parameterTypes;
     Type::ptr returnType;
+
+    [[nodiscard]] std::string print() const;
 };
 
 struct Value {
@@ -75,10 +77,9 @@ struct Test
     // after test launch
     std::optional<Value> returnValue;
 
-    [[nodiscard]] std::string resultMacroName() const;
-    void print(std::ostream &) const;
-    void printPreludeGenerator(std::ostream &) const;
-    void printFunctionCall(std::ostream &) const;
+    [[nodiscard]] std::string print() const;
+    [[nodiscard]] std::string printGenerator() const;
+    [[nodiscard]] std::string printFunctionCall() const;
 
     template <class Generator>
     static Test generate(Generator &gen, std::string name, TestSignature signature) {

src/test_main.cpp

@@ -15,26 +15,24 @@ TestMain &TestMain::add(Test test) {
 }
 
 void TestMain::usage() {
-    std::cerr << "Usage: " << args[0] << " <-g|-t>";
+    std::cerr << "Usage: " << args[0] << std::endl;
     std::exit(1);
 }
 
 void TestMain::run() {
-    if (args.size() != 2) {
+    if (args.size() != 1) {
         usage();
     }
 
-    if (args[1] == "-g") {
-        for (const auto& test : tests) {
-            test.printPreludeGenerator(std::cout);
-        }
-    } else if (args[1] == "-t") {
-        for (const auto& test : tests) {
-            test.print(std::cout);
-        }
-    } else {
-        usage();
+    std::cout << "#include <iostream>\n";
+    for (const auto& test : tests) {
+        std::cout << test.signature.print();
+    }
+    std::cout << "int main() {\n";
+    for (const auto& test : tests) {
+        std::cout << test.printGenerator();
     }
+    std::cout << "}\n";
 }
 
 TestMain &TestMain::fuzz(const TestSignature& testSignature, int n) {