Refactor some stuff

Author: tsarn

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.12)
 project(fuzz VERSION 0.1)
 
-add_executable(fuzz src/test.cpp src/test.h)
+add_executable(fuzz src/test.cpp src/test.h src/main.cpp)
 set_target_properties(fuzz PROPERTIES CXX_STANDARD 17)

src/main.cpp

@@ -0,0 +1,11 @@
+#include "test.h"
+#include <iostream>
+
+int main() {
+    Type tInt { PrimitiveType::INT };
+    TestSignature max{ "std::max", { tInt, tInt }, tInt };
+
+    std::mt19937 gen { std::random_device{}() };
+    std::cout << Test::generate(gen, "ExampleTest", max).print() << std::endl;
+    return 0;
+}

src/test.cpp

@@ -5,25 +5,28 @@
 std::string Value::print() const {
     return "static_cast<" + type.print() + ">(" + std::to_string(value) + ")";
 }
-
 std::string Type::print() const {
-    switch (kind) {
-        case Kind::PRIMITIVE_TYPE: return printPrimitiveType(primitiveType);
-        case Kind::POINTER: return pointerTo->print() + "*";
+    if (auto primitiveType = std::get_if<PrimitiveType>(&type)) {
+        return printPrimitiveType(*primitiveType);
+    } else if (auto pointerTo = std::get_if<PointerTo>(&type)) {
+        return pointerTo->type->print() + "*";
     }
+
+    return "<unknown>";
 }
 
 std::string printPrimitiveType(PrimitiveType type) {
     switch (type) {
         case PrimitiveType::CHAR: return "char";
         case PrimitiveType::INT: return "int";
     }
+    return "<unknown>";
 }
 
 std::string Test::print() const {
     std::stringstream ss;
     ss << "TEST(" << signature.name << "Test, " << name << ") {\n";
-    ss << "    EXPECT_EQ(" << signature.name << "(";
+    ss << "    " << signature.name << "(";
 
     bool first = true;
 
@@ -36,7 +39,7 @@ std::string Test::print() const {
 
         first = false;
     }
-    ss << "), " << returnValue.print() << ");\n";
+    ss << ");\n";
     ss << "}\n";
     return ss.str();
 }

src/test.h

@@ -2,14 +2,12 @@
 
 #include <vector>
 #include <string>
-#include <any>
+#include <variant>
 #include <optional>
 #include <memory>
+#include <random>
 
-enum class Kind {
-    PRIMITIVE_TYPE,
-    POINTER
-};
+struct Type;
 
 enum class PrimitiveType {
     CHAR,
@@ -18,19 +16,16 @@ enum class PrimitiveType {
 
 std::string printPrimitiveType(PrimitiveType type);
 
-struct Type {
-    union {
-        PrimitiveType primitiveType;
-        std::unique_ptr<Type> pointerTo;
-    };
+struct PointerTo {
+    std::shared_ptr<Type> type;
+};
 
-    Kind kind;
+struct Type {
+    std::variant<PrimitiveType, PointerTo> type;
 
     [[nodiscard]] std::string print() const;
 };
 
-std::any fillValue(Type x);
-
 struct TestSignature {
     std::string name;
     std::vector<Type> parameterTypes;
@@ -40,7 +35,14 @@ struct TestSignature {
 struct Value {
     Type type;
     int value;
+
     [[nodiscard]] std::string print() const;
+
+    template <class Generator>
+    static Value generate(Generator& gen, const Type& type) {
+        std::uniform_int_distribution<int> distribution;
+        return Value { type, distribution(gen) };
+    }
 };
 
 struct Test
@@ -50,7 +52,20 @@ struct Test
     std::vector<Value> arguments;
 
     // after test launch
-    Value returnValue;
+    std::optional<Value> returnValue;
 
     [[nodiscard]] std::string print() const;
+
+    template <class Generator>
+    static Test generate(Generator gen, std::string name, TestSignature signature) {
+        Test test;
+        test.name = std::move(name);
+        test.signature = std::move(signature);
+
+        for (const auto &type : test.signature.parameterTypes) {
+            test.arguments.push_back(Value::generate(gen, type));
+        }
+
+        return test;
+    }
 };