Support for values in range

Author: tsarn

src/main.cpp

@@ -2,7 +2,7 @@
 #include <iostream>
 
 int main() {
-    Type tInt { PrimitiveType::INT };
+    auto tInt = primitiveType(PrimitiveType::INT);
     TestSignature max{ "std::max", { tInt, tInt }, tInt };
 
     std::mt19937 gen { std::random_device{}() };

src/test.cpp

@@ -3,14 +3,16 @@
 #include <sstream>
 
 std::string Value::print() const {
-    return type.printValue(std::to_string(value));
+    return type->printValue(std::to_string(value));
 }
 
 std::string Type::print() const {
     if (auto primitiveType = std::get_if<PrimitiveType>(&type)) {
         return printPrimitiveType(*primitiveType);
     } else if (auto pointerTo = std::get_if<PointerTo>(&type)) {
         return pointerTo->type->print() + "*";
+    } else if (auto inRange = std::get_if<InRange>(&type)) {
+        return inRange->type->print();
     }
 
     return "<unknown>";
@@ -21,24 +23,33 @@ std::string Type::printValue(const std::string& value) const {
         return "static_cast<" + print() + ">(" + value + ")";
     } else if (auto pointerTo = std::get_if<PointerTo>(&type)) {
         return "new " + pointerTo->type->print() + "{" + pointerTo->type->printValue(value) + "}";
+    } else if (auto inRange = std::get_if<InRange>(&type)) {
+        return inRange->type->printValue(value);
     }
 
     return "<unknown>";
 }
 
-std::string printPrimitiveType(PrimitiveType type) {
-    switch (type) {
-        case PrimitiveType::CHAR: return "char";
-        case PrimitiveType::INT: return "int";
+std::pair<PrimitiveInteger, PrimitiveInteger> Type::getRange() const {
+    if (auto primitiveType = std::get_if<PrimitiveType>(&type)) {
+        int bitness = primitiveTypeSize(*primitiveType);
+        return { -(1ll << bitness), (1ll << bitness) - 1 };
+    } else if (auto pointerTo = std::get_if<PointerTo>(&type)) {
+        return pointerTo->type->getRange();
+    } else if (auto inRange = std::get_if<InRange>(&type)) {
+        auto enclosingRange = inRange->type->getRange();
+        return { std::max(enclosingRange.first, inRange->min),
+                 std::min(enclosingRange.second, inRange->max) };
     }
-    return "<unknown>";
+
+    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 << ", " << signature.returnType->printValue(resultMacroName()) << ");\n";
     ss << "}\n";
 }
 
@@ -73,3 +84,31 @@ void Test::printFunctionCall(std::ostream &ss) const {
 
     ss << ")";
 }
+
+std::string printPrimitiveType(PrimitiveType type) {
+    switch (type) {
+        case PrimitiveType::CHAR: return "char";
+        case PrimitiveType::INT: return "int";
+    }
+    return "<unknown>";
+}
+
+int primitiveTypeSize(PrimitiveType type) {
+    switch (type) {
+        case PrimitiveType::CHAR: return 8;
+        case PrimitiveType::INT: return 32;
+    }
+    return 0;
+}
+
+Type::ptr primitiveType(PrimitiveType type) {
+    return std::make_shared<Type>(Type { type });
+}
+
+Type::ptr primitiveType(PrimitiveType type, PrimitiveInteger min, PrimitiveInteger max) {
+    return std::make_shared<Type>( Type { InRange { primitiveType(type), min, max } } );
+}
+
+Type::ptr pointerTo(Type::ptr type) {
+    return std::make_shared<Type>(Type { PointerTo { std::move(type) } } );
+}

src/test.h

@@ -9,39 +9,58 @@
 
 struct Type;
 
+using PrimitiveInteger = long;
+
 enum class PrimitiveType {
     CHAR,
     INT
 };
 
-std::string printPrimitiveType(PrimitiveType type);
+[[nodiscard]] std::string printPrimitiveType(PrimitiveType type);
+[[nodiscard]] int primitiveTypeSize(PrimitiveType type);
 
 struct PointerTo {
     std::shared_ptr<Type> type;
 };
 
+struct InRange {
+    std::shared_ptr<Type> type;
+    PrimitiveInteger min, max;
+};
+
 struct Type {
-    std::variant<PrimitiveType, PointerTo> type;
+    std::variant<
+            PrimitiveType,
+            PointerTo,
+            InRange
+    > type;
+
+    using ptr = std::shared_ptr<Type>;
 
     [[nodiscard]] std::string print() const;
     [[nodiscard]] std::string printValue(const std::string &value) const;
+    [[nodiscard]] std::pair<PrimitiveInteger, PrimitiveInteger> getRange() const;
 };
 
+[[nodiscard]] Type::ptr primitiveType(PrimitiveType type);
+[[nodiscard]] Type::ptr primitiveType(PrimitiveType type, PrimitiveInteger min, PrimitiveInteger max);
+[[nodiscard]] Type::ptr pointerTo(Type::ptr type);
+
 struct TestSignature {
     std::string name;
-    std::vector<Type> parameterTypes;
-    Type returnType;
+    std::vector<Type::ptr> parameterTypes;
+    Type::ptr returnType;
 };
 
 struct Value {
-    Type type;
-    int value;
+    Type::ptr type;
+    PrimitiveInteger value;
 
     [[nodiscard]] std::string print() const;
 
     template <class Generator>
-    static Value generate(Generator& gen, const Type& type) {
-        std::uniform_int_distribution<int> distribution;
+    static Value generate(Generator& gen, const Type::ptr& type) {
+        std::uniform_int_distribution<PrimitiveInteger> distribution;
         return Value { type, distribution(gen) };
     }
 };