diff --git a/include/openspace/documentation/documentation.h b/include/openspace/documentation/documentation.h
index 91f37c0648..10e00ad2a0 100644
--- a/include/openspace/documentation/documentation.h
+++ b/include/openspace/documentation/documentation.h
@@ -36,14 +36,22 @@
 namespace openspace {
 namespace documentation {
 
-struct Verifier;
-
 using Optional = ghoul::Boolean;
 using Exhaustive = ghoul::Boolean;
 
 struct TestResult {
+    struct Offence {
+        enum class Reason {
+            MissingKey,
+            ExtraKey,
+            WrongType,
+            Verification
+        };
+        std::string offender;
+        Reason reason;
+    };
     bool success;
-    std::vector<std::string> offenders;
+    std::vector<Offence> offenders;
 };
 
 struct SpecificationError : public ghoul::RuntimeError {
@@ -52,6 +60,8 @@ struct SpecificationError : public ghoul::RuntimeError {
     TestResult result;
 };
 
+struct Verifier;
+
 struct DocumentationEntry {
     DocumentationEntry(std::string key, Verifier* t, std::string doc = "",
         Optional optional = Optional::No);
diff --git a/include/openspace/documentation/verifier.h b/include/openspace/documentation/verifier.h
index cd37530e22..4152f76135 100644
--- a/include/openspace/documentation/verifier.h
+++ b/include/openspace/documentation/verifier.h
@@ -27,14 +27,14 @@
 
 #include <openspace/documentation/documentation.h>
 
+#include <functional>
+
 namespace openspace {
 namespace documentation {
 
 struct Verifier {
-    virtual TestResult operator()(const ghoul::Dictionary& dict,
-                                  const std::string& key) const;
-
-    virtual bool test(const ghoul::Dictionary& dict, const std::string& key) const;
+    virtual TestResult operator()(const ghoul::Dictionary& dict, 
+        const std::string& key) const = 0;
 
     virtual std::string type() const = 0;
     virtual std::string documentation() const;
@@ -44,36 +44,36 @@ struct Verifier {
 template <typename T>
 struct TemplateVerifier : public Verifier {
     using Type = T;
+
+    TestResult operator()(const ghoul::Dictionary& dict,
+        const std::string& key) const override;
 };
 
 struct BoolVerifier : public TemplateVerifier<bool> {
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
-
     std::string type() const override;
 };
 
 struct DoubleVerifier : public TemplateVerifier<double> {
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
-
     std::string type() const override;
 };
 
 struct IntVerifier : public TemplateVerifier<int> {
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    TestResult operator()(const ghoul::Dictionary& dict,
+        const std::string& key) const override;
 
     std::string type() const override;
 };
 
 struct StringVerifier : public TemplateVerifier<std::string> {
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
-
     std::string type() const override;
 };
 
 struct TableVerifier : public TemplateVerifier<ghoul::Dictionary> {
-    TableVerifier(std::vector<DocumentationEntry> d = {}, Exhaustive exhaustive = Exhaustive::No);
+    TableVerifier(std::vector<DocumentationEntry> d = {},
+        Exhaustive exhaustive = Exhaustive::No);
 
-    TestResult operator()(const ghoul::Dictionary& dict, const std::string& key) const override;
+    TestResult operator()(const ghoul::Dictionary& dict,
+        const std::string& key) const override;
 
     std::string type() const override;
 
@@ -85,115 +85,94 @@ struct VectorVerifier {};
 
 template <typename T>
 struct Vector2Verifier : public TemplateVerifier<glm::tvec2<T>>, public VectorVerifier {
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
-
     std::string type() const override;
 };
 
 template <typename T>
 struct Vector3Verifier : public TemplateVerifier<glm::tvec3<T>>, public VectorVerifier {
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
-
     std::string type() const override;
 };
 
 template <typename T>
 struct Vector4Verifier : public TemplateVerifier<glm::tvec4<T>>, public VectorVerifier {
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
-
     std::string type() const override;
 };
 
 // Operator Verifiers
+template <typename T, typename Op>
+struct OperatorVerifier : public T {
+    OperatorVerifier(typename T::Type value);
+
+    TestResult operator()(const ghoul::Dictionary& dict,
+        const std::string& key) const override;
+
+    typename T::Type value;
+};
 
 template <typename T>
-struct LessVerifier : public T {
+struct LessVerifier : public OperatorVerifier<T, std::less<typename T::Type>> {
     static_assert(!std::is_base_of_v<BoolVerifier, T>, "T cannot be BoolVerifier");
     static_assert(!std::is_base_of_v<StringVerifier, T>, "T cannot be StringVerifier");
     static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
     static_assert(!std::is_base_of_v<VectorVerifier, T>, "T cannot be VectorVerifier");
 
-    LessVerifier(typename T::Type value);
-
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    using OperatorVerifier::OperatorVerifier;
 
     std::string documentation() const;
-
-    typename T::Type value;
 };
 
 template <typename T>
-struct LessEqualVerifier : public T {
+struct LessEqualVerifier : public OperatorVerifier<T, std::less_equal<typename T::Type>> {
     static_assert(!std::is_base_of_v<BoolVerifier, T>, "T cannot be BoolVerifier");
     static_assert(!std::is_base_of_v<StringVerifier, T>, "T cannot be StringVerifier");
     static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
     static_assert(!std::is_base_of_v<VectorVerifier, T>, "T cannot be VectorVerifier");
 
-    LessEqualVerifier(typename T::Type value);
-
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    using OperatorVerifier::OperatorVerifier;
 
     std::string documentation() const override;
-
-    typename T::Type value;
 };
 
 template <typename T>
-struct GreaterVerifier : public T {
+struct GreaterVerifier : public OperatorVerifier<T, std::greater<typename T::Type>> {
     static_assert(!std::is_base_of_v<BoolVerifier, T>, "T cannot be BoolVerifier");
     static_assert(!std::is_base_of_v<StringVerifier, T>, "T cannot be StringVerifier");
     static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
     static_assert(!std::is_base_of_v<VectorVerifier, T>, "T cannot be VectorVerifier");
 
-    GreaterVerifier(typename T::Type value);
-
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    using OperatorVerifier::OperatorVerifier;
 
     std::string documentation() const override;
-
-    typename T::Type value;
 };
 
 template <typename T>
-struct GreaterEqualVerifier : public T {
+struct GreaterEqualVerifier : public OperatorVerifier<T, std::greater_equal<typename T::Type>> {
     static_assert(!std::is_base_of_v<BoolVerifier, T>, "T cannot be BoolVerifier");
     static_assert(!std::is_base_of_v<StringVerifier, T>, "T cannot be StringVerifier");
     static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
     static_assert(!std::is_base_of_v<VectorVerifier, T>, "T cannot be VectorVerifier");
 
-    GreaterEqualVerifier(typename T::Type value);
-
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    using OperatorVerifier::OperatorVerifier;
 
     std::string documentation() const override;
-
-    typename T::Type value;
 };
 
 template <typename T>
-struct EqualVerifier : public T {
+struct EqualVerifier : public OperatorVerifier<T, std::equal_to<typename T::Type>> {
     static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
 
-    EqualVerifier(typename T::Type value);
-
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    using OperatorVerifier::OperatorVerifier;
 
     std::string documentation() const override;
-
-    typename T::Type value;
 };
 
 template <typename T>
-struct UnequalVerifier : public T {
+struct UnequalVerifier : public OperatorVerifier<T, std::not_equal_to<typename T::Type>> {
     static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
 
-    UnequalVerifier(typename T::Type value);
-
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    using OperatorVerifier::OperatorVerifier;
 
     std::string documentation() const override;
-
-    typename T::Type value;
 };
 
 // List Verifiers
@@ -204,7 +183,8 @@ struct InListVerifier : public T {
 
     InListVerifier(std::vector<typename T::Type> values);
 
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    TestResult operator()(const ghoul::Dictionary& dict,
+        const std::string& key) const override;
 
     std::string documentation() const override;
 
@@ -217,7 +197,8 @@ struct NotInListVerifier : public T {
 
     NotInListVerifier(std::vector<typename T::Type> values);
 
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    TestResult operator()(const ghoul::Dictionary& dict,
+        const std::string& key) const override;
 
     std::string documentation() const override;
 
@@ -234,7 +215,8 @@ struct InRangeVerifier : public T {
 
     InRangeVerifier(typename T::Type lower, typename T::Type upper);
 
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    TestResult operator()(const ghoul::Dictionary& dict,
+        const std::string& key) const override;
 
     std::string documentation() const override;
 
@@ -251,7 +233,8 @@ struct NotInRangeVerifier : public T {
 
     NotInRangeVerifier(typename T::Type lower, typename T::Type upper);
 
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    TestResult operator()(const ghoul::Dictionary& dict,
+        const std::string& key) const override;
 
     std::string documentation() const override;
 
@@ -265,8 +248,6 @@ template <typename T>
 struct AnnotationVerifier : public T {
     AnnotationVerifier(std::string annotation);
 
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
-
     std::string documentation() const override;
 
     std::string annotation;
@@ -277,7 +258,8 @@ struct AnnotationVerifier : public T {
 struct AndVerifier : public Verifier {
     AndVerifier(Verifier* a, Verifier* b);
 
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    TestResult operator()(const ghoul::Dictionary& dict,
+        const std::string& key) const override;
 
     std::string type() const override;
     std::string documentation() const override;
@@ -289,7 +271,8 @@ struct AndVerifier : public Verifier {
 struct OrVerifier : public Verifier {
     OrVerifier(Verifier* a, Verifier* b);
 
-    bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
+    TestResult operator()(const ghoul::Dictionary& dict,
+        const std::string& key) const override;
 
     std::string type() const override;
     std::string documentation() const override;
diff --git a/include/openspace/documentation/verifier.inl b/include/openspace/documentation/verifier.inl
index bfc155dae8..2e0891489d 100644
--- a/include/openspace/documentation/verifier.inl
+++ b/include/openspace/documentation/verifier.inl
@@ -32,8 +32,20 @@ namespace openspace {
 namespace documentation {
 
 template <typename T>
-bool Vector2Verifier<T>::test(const ghoul::Dictionary& d, const std::string& k) const {
-    return d.hasKeyAndValue<glm::tvec2<T>>(k);
+TestResult TemplateVerifier<T>::operator()(const ghoul::Dictionary& dict,
+                                           const std::string& key) const
+{
+    if (dict.hasKey(key)) {
+        if (dict.hasValue<Type>(key)) {
+            return{ true, {} };
+        }
+        else {
+            return { false, { { key, TestResult::Offence::Reason::WrongType } } };
+        }
+    }
+    else {
+        return { false, { { key, TestResult::Offence::Reason::MissingKey } } };
+    }
 }
 
 template <typename T>
@@ -43,11 +55,6 @@ std::string Vector2Verifier<T>::type() const {
     return "Vector2<"s + typeid(T).name() + ">";
 }
 
-template <typename T>
-bool Vector3Verifier<T>::test(const ghoul::Dictionary& d, const std::string& k) const {
-    return d.hasKeyAndValue<glm::tvec3<T>>(k);
-}
-
 template <typename T>
 std::string Vector3Verifier<T>::type() const {
     using namespace std::string_literals;
@@ -55,11 +62,6 @@ std::string Vector3Verifier<T>::type() const {
     return "Vector3<"s + typeid(T).name() + ">";
 }
 
-template <typename T>
-bool Vector4Verifier<T>::test(const ghoul::Dictionary& d, const std::string& k) const {
-    return d.hasKeyAndValue<glm::tvec4<T>>(k);
-}
-
 template <typename T>
 std::string Vector4Verifier<T>::type() const {
     using namespace std::string_literals;
@@ -67,15 +69,27 @@ std::string Vector4Verifier<T>::type() const {
     return "Vector4<"s + typeid(T).name() + ">";
 }
 
-template <typename T>
-LessVerifier<T>::LessVerifier(typename T::Type value) 
+template <typename T, typename Op>
+OperatorVerifier<T, Op>::OperatorVerifier(typename T::Type value)
     : value(std::move(value))
-{
-}
+{}
 
-template <typename T>
-bool LessVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    return T::test(dict, key) && dict.value<Type>(key) < value;
+template <typename T, typename Op>
+TestResult OperatorVerifier<T, Op>::operator()(const ghoul::Dictionary& dict,
+                                               const std::string& key) const 
+{
+    TestResult res = T::operator()(dict, key);
+    if (res.success) {
+        if (Op()(dict.value<Type>(key), value)) {
+            return { true, {} };
+        }
+        else {
+            return { false, { { key, TestResult::Offence::Reason::Verification }}};
+        }
+    }
+    else {
+        return res;
+    }
 }
 
 template <typename T>
@@ -83,77 +97,26 @@ std::string LessVerifier<T>::documentation() const {
     return "Less than: " + std::to_string(value);
 }
 
-
-template <typename T>
-LessEqualVerifier<T>::LessEqualVerifier(typename T::Type value)
-    : value(std::move(value))
-{}
-
-template <typename T>
-bool LessEqualVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    return T::test(dict, key) && dict.value<Type>(key) <= value;
-}
-
 template <typename T>
 std::string LessEqualVerifier<T>::documentation() const {
     return "Less or equal to: " + std::to_string(value);
 }
 
-template <typename T>
-GreaterVerifier<T>::GreaterVerifier(typename T::Type value)
-    : value(std::move(value))
-{}
-
-template <typename T>
-bool GreaterVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    return T::test(dict, key) && dict.value<Type>(key) > value;
-}
-
 template <typename T>
 std::string GreaterVerifier<T>::documentation() const {
     return "Greater than: " + std::to_string(value);
 }
 
-template <typename T>
-GreaterEqualVerifier<T>::GreaterEqualVerifier(typename T::Type value)
-    : value(std::move(value)) 
-{}
-
-template <typename T>
-bool GreaterEqualVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    return T::test(dict, key) && dict.value<Type>(key) >= value;
-}
-
 template <typename T>
 std::string GreaterEqualVerifier<T>::documentation() const {
     return "Greater or equal to: " + std::to_string(value);
 }
 
-template <typename T>
-EqualVerifier<T>::EqualVerifier(typename T::Type value) 
-    : value(std::move(value)) 
-{}
-
-template <typename T>
-bool EqualVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    return T::test(dict, key) && dict.value<Type>(key) == value;
-}
-
 template <typename T>
 std::string EqualVerifier<T>::documentation() const {
     return "Equal to: " + std::to_string(value);
 }
 
-template <typename T>
-UnequalVerifier<T>::UnequalVerifier(typename T::Type value)
-    : value(std::move(value))
-{}
-
-template <typename T>
-bool UnequalVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    return T::test(dict, key) && dict.value<Type>(key) != value;
-}
-
 template <typename T>
 std::string UnequalVerifier<T>::documentation() const {
     return "Unequal to: " + std::to_string(value);
@@ -165,15 +128,24 @@ InListVerifier<T>::InListVerifier(std::vector<typename T::Type> values)
 {}
 
 template <typename T>
-bool InListVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    if (T::test(dict, key)) {
+TestResult InListVerifier<T>::operator()(const ghoul::Dictionary& dict,
+                                         const std::string& key) const
+{
+    TestResult res = T::operator()(dict, key);
+    if (res.success) {
         typename T::Type value = dict.value<typename T::Type>(key);
 
         auto it = std::find(values.begin(), values.end(), value);
-        return it != values.end();
+
+        if (it != values.end()) {
+            return { true, {} };
+        }
+        else {
+            return { false, { { key, TestResult::Offence::Reason::Verification } } };
+        }
     }
     else {
-        return false;
+        return res;
     }
 }
 
@@ -198,15 +170,24 @@ NotInListVerifier<T>::NotInListVerifier(std::vector<typename T::Type> values)
 {}
 
 template <typename T>
-bool NotInListVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    if (T::test(dict, key)) {
+TestResult NotInListVerifier<T>::operator()(const ghoul::Dictionary& dict,
+                                         const std::string& key) const
+{
+    TestResult res = T::operator()(dict, key);
+    if (res.success) {
         typename T::Type value = dict.value<typename T::Type>(key);
 
         auto it = std::find(values.begin(), values.end(), value);
-        return it == values.end();
+
+        if (it == values.end()) {
+            return { true, {} };
+        }
+        else {
+            return { false, { { key, TestResult::Offence::Reason::Verification } } };
+        }
     }
     else {
-        return false;
+        return res;
     }
 }
 
@@ -234,14 +215,24 @@ InRangeVerifier<T>::InRangeVerifier(typename T::Type lower, typename T::Type upp
     ghoul_assert(lower <= upper, "Lower value must be smaller or equal to upper value");
 }
 
+
 template <typename T>
-bool InRangeVerifier<T>::test(const ghoul::Dictionary& d, const std::string& key) const {
-    if (T::test(d, key)) {
-        typename T::Type val = d.value<typename T::Type>(key);
-        return val >= lower && val <= upper;
+TestResult InRangeVerifier<T>::operator()(const ghoul::Dictionary& dict,
+                                          const std::string& key) const
+{
+    TestResult res = T::operator()(dict, key);
+    if (res.success) {
+        typename T::Type val = dict.value<typename T::Type>(key);
+
+        if (val >= lower && val <= upper) {
+            return { true, {} };
+        }
+        else {
+            return { false, { { key, TestResult::Offence::Reason::Verification } } };
+        }
     }
     else {
-        return false;
+        return res;
     }
 }
 
@@ -260,13 +251,21 @@ NotInRangeVerifier<T>::NotInRangeVerifier(typename T::Type lower, typename T::Ty
 }
 
 template <typename T>
-bool NotInRangeVerifier<T>::test(const ghoul::Dictionary& d, const std::string& k) const {
-    if (T::test(d, k)) {
-        typename T::Type val = d.value<typename T::Type>(k);
-        return !(val >= lower && val <= upper);
+TestResult NotInRangeVerifier<T>::operator()(const ghoul::Dictionary& dict,
+                                          const std::string& key) const {
+    TestResult res = T::operator()(dict, key);
+    if (res.success) {
+        typename T::Type val = dict.value<typename T::Type>(key);
+
+        if (val >= lower && val <= upper) {
+            return { false, { { key, TestResult::Offence::Reason::Verification } } };
+        }
+        else {
+            return { true, {} };
+        }
     }
     else {
-        return false;
+        return res;
     }
 }
 
@@ -282,12 +281,6 @@ AnnotationVerifier<T>::AnnotationVerifier(std::string annotation)
     : annotation(std::move(annotation))
 {}
 
-template <typename T>
-bool AnnotationVerifier<T>::test(const ghoul::Dictionary& dict,
-                                 const std::string& key) const
-{
-    return T::test(dict, key);
-}
 
 template <typename T>
 std::string AnnotationVerifier<T>::documentation() const {
diff --git a/src/documentation/documentation.cpp b/src/documentation/documentation.cpp
index b908c5d551..6a1fd379fa 100644
--- a/src/documentation/documentation.cpp
+++ b/src/documentation/documentation.cpp
@@ -29,6 +29,22 @@
 
 namespace {
     const std::string Wildcard = "*";
+
+    // Structure used to make offences unique
+    struct OffenceCompare {
+        using Offence = openspace::documentation::TestResult::Offence;
+        bool operator()(const Offence& lhs, const Offence& rhs) const
+        {
+            if (lhs.offender != rhs.offender) {
+                return lhs.offender < rhs.offender;
+            }
+            else {
+                return std::underlying_type_t<Offence::Reason>(lhs.reason) <
+                    std::underlying_type_t<Offence::Reason>(rhs.reason);
+            }
+        }
+
+    };
 } // namespace
 
 namespace std {
@@ -119,17 +135,19 @@ TestResult testSpecification(const Documentation& d, const ghoul::Dictionary& di
 
             if (it == d.entries.end()) {
                 result.success = false;
-                result.offenders.push_back(key);
+                result.offenders.push_back(
+                    { key, TestResult::Offence::Reason::ExtraKey }
+                );
             }
         }
     }
 
     // Remove duplicate offenders that might occur if multiple rules apply to a single
     // key and more than one of these rules are broken
-    std::set<std::string> uniqueOffenders(
+    std::set<TestResult::Offence, OffenceCompare> uniqueOffenders(
         result.offenders.begin(), result.offenders.end()
     );
-    result.offenders = std::vector<std::string>(
+    result.offenders = std::vector<TestResult::Offence>(
         uniqueOffenders.begin(), uniqueOffenders.end()
     );
 
diff --git a/src/documentation/verifier.cpp b/src/documentation/verifier.cpp
index c1db34e868..af51e33c51 100644
--- a/src/documentation/verifier.cpp
+++ b/src/documentation/verifier.cpp
@@ -74,56 +74,45 @@ template struct AnnotationVerifier<DoubleVerifier>;
 template struct AnnotationVerifier<StringVerifier>;
 template struct AnnotationVerifier<TableVerifier>;
 
-TestResult Verifier::operator()(const ghoul::Dictionary& dict,
-                                const std::string& key) const
-{
-    bool testSuccess = test(dict, key);
-    if (testSuccess) {
-        return { testSuccess,{} };
-    }
-    else {
-        return { testSuccess,{ key } };
-    }
-}
-
-bool Verifier::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    return false;
-};
-
 std::string Verifier::documentation() const {
     return "";
 }
 
-bool BoolVerifier::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    return dict.hasKeyAndValue<Type>(key);
-}
-
 std::string BoolVerifier::type() const {
     return "Boolean";
 }
 
-bool DoubleVerifier::test(const ghoul::Dictionary & dict, const std::string & key) const {
-    return dict.hasKeyAndValue<Type>(key);
-}
-
 std::string DoubleVerifier::type() const {
     return "Double";
 }
 
-bool IntVerifier::test(const ghoul::Dictionary & dict, const std::string & key) const {
+TestResult IntVerifier::operator()(const ghoul::Dictionary & dict,
+                             const std::string & key) const
+{
     if (dict.hasKeyAndValue<int>(key)) {
-        return true;
+        return { true, {} };
     }
     else {
-        if (dict.hasKeyAndValue<double>(key)) {
-            // If we have a double value, we need to check if it is integer
-            double value = dict.value<double>(key);
-            double intPart;
-            return modf(value, &intPart) == 0.0;
+        if (dict.hasKey(key)) {
+            if (dict.hasValue<double>(key)) {
+                // If we have a double value, we need to check if it is integer
+                double value = dict.value<double>(key);
+                double intPart;
+                bool isInt = modf(value, &intPart) == 0.0;
+                if (isInt) {
+                    return { true,{} };
+                }
+                else {
+                    return { false, { { key, TestResult::Offence::Reason::WrongType } } };
+                }
+            }
+            else {
+                // If we don't have a double value, we cannot have an int value
+                return { false, { { key, TestResult::Offence::Reason::WrongType } } };
+            }
         }
         else {
-            // If we don't have a double value, we cannot have an int value
-            return false;
+            return { false, { {key, TestResult::Offence::Reason::MissingKey }}};
         }
     }
 }
@@ -132,10 +121,6 @@ std::string IntVerifier::type() const {
     return "Integer";
 }
 
-bool StringVerifier::test(const ghoul::Dictionary & dict, const std::string & key) const {
-    return dict.hasKeyAndValue<Type>(key);
-}
-
 std::string StringVerifier::type() const {
     return "String";
 }
@@ -149,16 +134,24 @@ TestResult TableVerifier::operator()(const ghoul::Dictionary& dict,
                                      const std::string& key) const
 {
     if (dict.hasKeyAndValue<Type>(key)) {
-        ghoul::Dictionary d = dict.value<Type>(key);
+        ghoul::Dictionary d = dict.value<ghoul::Dictionary>(key);
         TestResult res = testSpecification({ "", doc, exhaustive }, d);
 
-        for (std::string& s : res.offenders) {
-            s = key + "." + s;
+        for (TestResult::Offence& s : res.offenders) {
+            s.offender = key + "." + s.offender;
         }
 
         return res;
     }
-    return { dict.hasKeyAndValue<Type>(key), { key } };
+    else {
+        if (dict.hasKey(key)) {
+            return { false, { { key, TestResult::Offence::Reason::WrongType } } };
+
+        }
+        else {
+            return { false, { { key, TestResult::Offence::Reason::MissingKey } } };
+        }
+    }
 }
 
 std::string TableVerifier::type() const {
@@ -172,8 +165,18 @@ AndVerifier::AndVerifier(Verifier* a, Verifier* b)
     ghoul_assert(a->type() == b->type(), "Cannot use AndVerifier with different types");
 }
 
-bool AndVerifier::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    return a->test(dict, key) && b->test(dict, key);
+TestResult AndVerifier::operator()(const ghoul::Dictionary& dict,
+                                   const std::string& key) const 
+{
+    TestResult resA = a->operator()(dict, key);
+    TestResult resB = b->operator()(dict, key);
+
+    if (resA.success && resB.success) {
+        return { true, {} };
+    }
+    else {
+        return { false, { { key, TestResult::Offence::Reason::Verification } } };
+    }
 }
 
 std::string AndVerifier::type() const {
@@ -190,8 +193,17 @@ OrVerifier::OrVerifier(Verifier* a, Verifier* b)
     , b(b) 
 {}
 
-bool OrVerifier::test(const ghoul::Dictionary& dict, const std::string& key) const {
-    return a->test(dict, key) || b->test(dict, key);
+TestResult OrVerifier::operator()(const ghoul::Dictionary& dict,
+                                   const std::string& key) const {
+    TestResult resA = a->operator()(dict, key);
+    TestResult resB = b->operator()(dict, key);
+
+    if (resA.success || resB.success) {
+        return { true, {} };
+    }
+    else {
+        return { false, { { key, TestResult::Offence::Reason::Verification } } };
+    }
 }
 
 std::string OrVerifier::type() const {
diff --git a/tests/test_documentation.inl b/tests/test_documentation.inl
index 34e8d05f6b..bff9c7dfb0 100644
--- a/tests/test_documentation.inl
+++ b/tests/test_documentation.inl
@@ -180,7 +180,8 @@ TEST_F(DocumentationTest, BoolVerifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Bool", negativeRes.offenders[0]);
+    EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
     
     ghoul::Dictionary negativeExist {
         { "Bool2", 0}
@@ -189,7 +190,8 @@ TEST_F(DocumentationTest, BoolVerifier) {
 
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Bool", negativeRes.offenders[0]);
+    EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, DoubleVerifier) {
@@ -215,15 +217,17 @@ TEST_F(DocumentationTest, DoubleVerifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negativeExist{
         { "Double2" , 0.0 }
     };
-    negativeRes = testSpecification(doc, negative);
+    negativeRes = testSpecification(doc, negativeExist);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, IntVerifier) {
@@ -255,15 +259,17 @@ TEST_F(DocumentationTest, IntVerifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negativeExist {
         { "Int2", 0 }
     };
-    negativeRes = testSpecification(doc, negative);
+    negativeRes = testSpecification(doc, negativeExist);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, StringVerifier) {
@@ -288,15 +294,17 @@ TEST_F(DocumentationTest, StringVerifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("String", negativeRes.offenders[0]);
+    EXPECT_EQ("String", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negativeExist {
         { "String2", ""s }
     };
-    negativeRes = testSpecification(doc, negative);
+    negativeRes = testSpecification(doc, negativeExist);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("String", negativeRes.offenders[0]);
+    EXPECT_EQ("String", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, TableVerifierType) {
@@ -320,15 +328,17 @@ TEST_F(DocumentationTest, TableVerifierType) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Table", negativeRes.offenders[0]);
+    EXPECT_EQ("Table", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negativeExist {
         { "Table2", ghoul::Dictionary{} }
     };
-    negativeRes = testSpecification(doc, negative);
+    negativeRes = testSpecification(doc, negativeExist);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Table", negativeRes.offenders[0]);
+    EXPECT_EQ("Table", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, MixedVerifiers) {
@@ -367,7 +377,8 @@ TEST_F(DocumentationTest, MixedVerifiers) {
     TestResult negativeRes = testSpecification(doc, negative1);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "Bool", true },
@@ -379,8 +390,10 @@ TEST_F(DocumentationTest, MixedVerifiers) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(2, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
-    EXPECT_EQ("String", negativeRes.offenders[1]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
+    EXPECT_EQ("String", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
 }
 
 TEST_F(DocumentationTest, NestedTables) {
@@ -440,7 +453,8 @@ TEST_F(DocumentationTest, NestedTables) {
     TestResult negativeRes = testSpecification(doc, negativeSimple);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Outer_Table", negativeRes.offenders[0]);
+    EXPECT_EQ("Outer_Table", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negativeInner {
         { "Outer_Int", 1 },
@@ -460,7 +474,8 @@ TEST_F(DocumentationTest, NestedTables) {
     negativeRes = testSpecification(doc, negativeInner);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negativeInner2 {
         { "Outer_Int", 1 },
@@ -480,8 +495,10 @@ TEST_F(DocumentationTest, NestedTables) {
     negativeRes = testSpecification(doc, negativeInner2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(2, negativeRes.offenders.size());
-    EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0]);
-    EXPECT_EQ("Outer_Table.Inner_String", negativeRes.offenders[1]);
+    EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
+    EXPECT_EQ("Outer_Table.Inner_String", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
 
     ghoul::Dictionary negativeInnerSeparate {
         { "Outer_Int", 1 },
@@ -501,8 +518,10 @@ TEST_F(DocumentationTest, NestedTables) {
     negativeRes = testSpecification(doc, negativeInnerSeparate);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(2, negativeRes.offenders.size());
-    EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0]);
-    EXPECT_EQ("Outer_Table2.Inner_Double2", negativeRes.offenders[1]);
+    EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
+    EXPECT_EQ("Outer_Table2.Inner_Double2", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
 
     ghoul::Dictionary negativeInnerFull {
         { "Outer_Int", 1 },
@@ -522,9 +541,12 @@ TEST_F(DocumentationTest, NestedTables) {
     negativeRes = testSpecification(doc, negativeInnerFull);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(3, negativeRes.offenders.size());
-    EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0]);
-    EXPECT_EQ("Outer_Table2.Inner_Double2", negativeRes.offenders[1]);
-    EXPECT_EQ("Outer_Table2.Inner_Table.Inner_Inner_Int", negativeRes.offenders[2]);
+    EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
+    EXPECT_EQ("Outer_Table2.Inner_Double2", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
+    EXPECT_EQ("Outer_Table2.Inner_Table.Inner_Inner_Int", negativeRes.offenders[2].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[2].reason);
 }
 
 TEST_F(DocumentationTest, Optional) {
@@ -558,7 +580,8 @@ TEST_F(DocumentationTest, Optional) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Bool_Force", negativeRes.offenders[0]);
+    EXPECT_EQ("Bool_Force", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "Bool_Optional", true }
@@ -566,7 +589,8 @@ TEST_F(DocumentationTest, Optional) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Bool_Force", negativeRes.offenders[0]);
+    EXPECT_EQ("Bool_Force", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative3 {
         { "Bool_Force", true },
@@ -575,7 +599,8 @@ TEST_F(DocumentationTest, Optional) {
     negativeRes = testSpecification(doc, negative3);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Bool_Optional", negativeRes.offenders[0]);
+    EXPECT_EQ("Bool_Optional", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, RequiredInOptional) {
@@ -636,7 +661,8 @@ TEST_F(DocumentationTest, RequiredInOptional) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a.b", negativeRes.offenders[0]);
+    EXPECT_EQ("a.b", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, Exhaustive) {
@@ -661,8 +687,10 @@ TEST_F(DocumentationTest, Exhaustive) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(2, negativeRes.offenders.size());
-    EXPECT_EQ("False_Int", negativeRes.offenders[0]);
-    EXPECT_EQ("Int", negativeRes.offenders[1]);
+    EXPECT_EQ("False_Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::ExtraKey, negativeRes.offenders[0].reason);
+    EXPECT_EQ("Int", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[1].reason);
 
     ghoul::Dictionary negative2 {
         { "Double", 2.0 }
@@ -670,8 +698,10 @@ TEST_F(DocumentationTest, Exhaustive) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(2, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
-    EXPECT_EQ("Int", negativeRes.offenders[1]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::ExtraKey, negativeRes.offenders[0].reason);
+    EXPECT_EQ("Int", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[1].reason);
 }
 
 TEST_F(DocumentationTest, NestedExhaustive) {
@@ -699,8 +729,10 @@ TEST_F(DocumentationTest, NestedExhaustive) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(2, negativeRes.offenders.size());
-    EXPECT_EQ("Table.a", negativeRes.offenders[0]);
-    EXPECT_EQ("Table.b", negativeRes.offenders[1]);
+    EXPECT_EQ("Table.a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
+    EXPECT_EQ("Table.b", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::ExtraKey, negativeRes.offenders[1].reason);
 }
 
 TEST_F(DocumentationTest, LessInt) {
@@ -724,7 +756,8 @@ TEST_F(DocumentationTest, LessInt) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, LessDouble) {
@@ -748,7 +781,8 @@ TEST_F(DocumentationTest, LessDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, LessEqualInt) {
@@ -779,7 +813,8 @@ TEST_F(DocumentationTest, LessEqualInt) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, LessEqualDouble) {
@@ -810,7 +845,8 @@ TEST_F(DocumentationTest, LessEqualDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, GreaterInt) {
@@ -829,12 +865,13 @@ TEST_F(DocumentationTest, GreaterInt) {
     EXPECT_EQ(0, positiveRes.offenders.size());
 
     ghoul::Dictionary negative {
-        { "Int", 00 }
+        { "Int", 0 }
     };
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, GreaterDouble) {
@@ -858,7 +895,8 @@ TEST_F(DocumentationTest, GreaterDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, GreaterEqualInt) {
@@ -889,7 +927,8 @@ TEST_F(DocumentationTest, GreaterEqualInt) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, GreaterEqualDouble) {
@@ -920,10 +959,10 @@ TEST_F(DocumentationTest, GreaterEqualDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
-
 TEST_F(DocumentationTest, EqualBool) {
     using namespace openspace::documentation;
 
@@ -945,7 +984,8 @@ TEST_F(DocumentationTest, EqualBool) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Bool", negativeRes.offenders[0]);
+    EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, EqualInt) {
@@ -969,7 +1009,8 @@ TEST_F(DocumentationTest, EqualInt) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, EqualDouble) {
@@ -993,7 +1034,8 @@ TEST_F(DocumentationTest, EqualDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, EqualString) {
@@ -1018,7 +1060,8 @@ TEST_F(DocumentationTest, EqualString) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("String", negativeRes.offenders[0]);
+    EXPECT_EQ("String", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, UnequalBool) {
@@ -1042,7 +1085,8 @@ TEST_F(DocumentationTest, UnequalBool) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Bool", negativeRes.offenders[0]);
+    EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, UnequalInt) {
@@ -1066,7 +1110,8 @@ TEST_F(DocumentationTest, UnequalInt) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, UnequalDouble) {
@@ -1090,7 +1135,8 @@ TEST_F(DocumentationTest, UnequalDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, UnequalString) {
@@ -1115,7 +1161,8 @@ TEST_F(DocumentationTest, UnequalString) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("String", negativeRes.offenders[0]);
+    EXPECT_EQ("String", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, ListBool) {
@@ -1139,7 +1186,8 @@ TEST_F(DocumentationTest, ListBool) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Bool", negativeRes.offenders[0]);
+    EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, ListInt) {
@@ -1170,7 +1218,8 @@ TEST_F(DocumentationTest, ListInt) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, ListDouble) {
@@ -1201,7 +1250,8 @@ TEST_F(DocumentationTest, ListDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, ListString) {
@@ -1233,7 +1283,8 @@ TEST_F(DocumentationTest, ListString) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("String", negativeRes.offenders[0]);
+    EXPECT_EQ("String", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, NotListBool) {
@@ -1257,7 +1308,8 @@ TEST_F(DocumentationTest, NotListBool) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Bool", negativeRes.offenders[0]);
+    EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, NotListInt) {
@@ -1288,7 +1340,8 @@ TEST_F(DocumentationTest, NotListInt) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, NotListDouble) {
@@ -1319,7 +1372,8 @@ TEST_F(DocumentationTest, NotListDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, NotListString) {
@@ -1351,7 +1405,8 @@ TEST_F(DocumentationTest, NotListString) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("String", negativeRes.offenders[0]);
+    EXPECT_EQ("String", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, AnnotationBool) {
@@ -1375,7 +1430,8 @@ TEST_F(DocumentationTest, AnnotationBool) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Bool", negativeRes.offenders[0]);
+    EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, AnnotationInt) {
@@ -1399,7 +1455,8 @@ TEST_F(DocumentationTest, AnnotationInt) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, AnnotationDouble) {
@@ -1423,7 +1480,8 @@ TEST_F(DocumentationTest, AnnotationDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, AnnotationString) {
@@ -1448,7 +1506,8 @@ TEST_F(DocumentationTest, AnnotationString) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("String", negativeRes.offenders[0]);
+    EXPECT_EQ("String", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, AnnotationTable) {
@@ -1472,7 +1531,8 @@ TEST_F(DocumentationTest, AnnotationTable) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Table", negativeRes.offenders[0]);
+    EXPECT_EQ("Table", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, InRangeInt) {
@@ -1510,7 +1570,8 @@ TEST_F(DocumentationTest, InRangeInt) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, InRangeDouble) {
@@ -1555,7 +1616,8 @@ TEST_F(DocumentationTest, InRangeDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, NotInRangeInt) {
@@ -1586,7 +1648,8 @@ TEST_F(DocumentationTest, NotInRangeInt) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "Int", 0 }
@@ -1594,7 +1657,8 @@ TEST_F(DocumentationTest, NotInRangeInt) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative3 {
         { "Int", 5 }
@@ -1602,7 +1666,8 @@ TEST_F(DocumentationTest, NotInRangeInt) {
     negativeRes = testSpecification(doc, negative3);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Int", negativeRes.offenders[0]);
+    EXPECT_EQ("Int", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, NotInRangeDouble) {
@@ -1633,7 +1698,8 @@ TEST_F(DocumentationTest, NotInRangeDouble) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "Double", 5.0 }
@@ -1641,7 +1707,8 @@ TEST_F(DocumentationTest, NotInRangeDouble) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative3 {
         { "Double", 2.5 }
@@ -1649,7 +1716,8 @@ TEST_F(DocumentationTest, NotInRangeDouble) {
     negativeRes = testSpecification(doc, negative3);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("Double", negativeRes.offenders[0]);
+    EXPECT_EQ("Double", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, Wildcard) {
@@ -1677,7 +1745,8 @@ TEST_F(DocumentationTest, Wildcard) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "a", false },
@@ -1687,8 +1756,10 @@ TEST_F(DocumentationTest, Wildcard) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(2, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
-    EXPECT_EQ("b", negativeRes.offenders[1]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
+    EXPECT_EQ("b", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
 
     ghoul::Dictionary negative3 {
         { "a", false },
@@ -1698,9 +1769,12 @@ TEST_F(DocumentationTest, Wildcard) {
     negativeRes = testSpecification(doc, negative3);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(3, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
-    EXPECT_EQ("b", negativeRes.offenders[1]);
-    EXPECT_EQ("c", negativeRes.offenders[2]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
+    EXPECT_EQ("b", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
+    EXPECT_EQ("c", negativeRes.offenders[2].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[2].reason);
 }
 
 TEST_F(DocumentationTest, WildcardMixed) {
@@ -1731,8 +1805,10 @@ TEST_F(DocumentationTest, WildcardMixed) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(2, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
-    EXPECT_EQ("b", negativeRes.offenders[1]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
+    EXPECT_EQ("b", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[1].reason);
 
     ghoul::Dictionary negative2 {
         { "a", false },
@@ -1742,8 +1818,10 @@ TEST_F(DocumentationTest, WildcardMixed) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(2, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
-    EXPECT_EQ("b", negativeRes.offenders[1]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
+    EXPECT_EQ("b", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
 
     ghoul::Dictionary negative3 {
         { "a", false },
@@ -1753,9 +1831,12 @@ TEST_F(DocumentationTest, WildcardMixed) {
     negativeRes = testSpecification(doc, negative3);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(3, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
-    EXPECT_EQ("b", negativeRes.offenders[1]);
-    EXPECT_EQ("c", negativeRes.offenders[2]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
+    EXPECT_EQ("b", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[1].reason);
+    EXPECT_EQ("c", negativeRes.offenders[2].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[2].reason);
 
     ghoul::Dictionary negative4 {
         { "a", false },
@@ -1765,8 +1846,10 @@ TEST_F(DocumentationTest, WildcardMixed) {
     negativeRes = testSpecification(doc, negative4);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(2, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
-    EXPECT_EQ("c", negativeRes.offenders[1]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
+    EXPECT_EQ("c", negativeRes.offenders[1].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
 }
 
 TEST_F(DocumentationTest, AndOperator) {
@@ -1795,7 +1878,8 @@ TEST_F(DocumentationTest, AndOperator) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "a", 8 }
@@ -1803,7 +1887,8 @@ TEST_F(DocumentationTest, AndOperator) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, OrOperator) {
@@ -1835,7 +1920,8 @@ TEST_F(DocumentationTest, OrOperator) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, BoolVector2Verifier) {
@@ -1854,12 +1940,13 @@ TEST_F(DocumentationTest, BoolVector2Verifier) {
     EXPECT_EQ(0, positiveRes.offenders.size());
 
     ghoul::Dictionary negative {
-        { "a", ghoul::Dictionary{ {"1", true}, {"2", 1.0} } }
+        { "a", ghoul::Dictionary{ { "1", true }, { "2", 1.0 } } }
     };
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "a", true }
@@ -1867,7 +1954,8 @@ TEST_F(DocumentationTest, BoolVector2Verifier) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, IntVector2Verifier) {
@@ -1891,7 +1979,8 @@ TEST_F(DocumentationTest, IntVector2Verifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "a", true }
@@ -1899,7 +1988,8 @@ TEST_F(DocumentationTest, IntVector2Verifier) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, DoubleVector2Verifier) {
@@ -1923,7 +2013,8 @@ TEST_F(DocumentationTest, DoubleVector2Verifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "a", true }
@@ -1931,7 +2022,8 @@ TEST_F(DocumentationTest, DoubleVector2Verifier) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, BoolVector3Verifier) {
@@ -1955,7 +2047,8 @@ TEST_F(DocumentationTest, BoolVector3Verifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "a", true }
@@ -1963,7 +2056,8 @@ TEST_F(DocumentationTest, BoolVector3Verifier) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, IntVector3Verifier) {
@@ -1987,7 +2081,8 @@ TEST_F(DocumentationTest, IntVector3Verifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "a", true }
@@ -1995,7 +2090,8 @@ TEST_F(DocumentationTest, IntVector3Verifier) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, DoubleVector3Verifier) {
@@ -2019,7 +2115,8 @@ TEST_F(DocumentationTest, DoubleVector3Verifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "a", true }
@@ -2027,7 +2124,8 @@ TEST_F(DocumentationTest, DoubleVector3Verifier) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, BoolVector4Verifier) {
@@ -2051,7 +2149,8 @@ TEST_F(DocumentationTest, BoolVector4Verifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "a", true }
@@ -2059,7 +2158,8 @@ TEST_F(DocumentationTest, BoolVector4Verifier) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, IntVector4Verifier) {
@@ -2083,7 +2183,8 @@ TEST_F(DocumentationTest, IntVector4Verifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2{
         { "a", true }
@@ -2091,7 +2192,8 @@ TEST_F(DocumentationTest, IntVector4Verifier) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }
 
 TEST_F(DocumentationTest, DoubleVector4Verifier) {
@@ -2115,7 +2217,8 @@ TEST_F(DocumentationTest, DoubleVector4Verifier) {
     TestResult negativeRes = testSpecification(doc, negative);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 
     ghoul::Dictionary negative2 {
         { "a", true }
@@ -2123,5 +2226,6 @@ TEST_F(DocumentationTest, DoubleVector4Verifier) {
     negativeRes = testSpecification(doc, negative2);
     EXPECT_FALSE(negativeRes.success);
     ASSERT_EQ(1, negativeRes.offenders.size());
-    EXPECT_EQ("a", negativeRes.offenders[0]);
+    EXPECT_EQ("a", negativeRes.offenders[0].offender);
+    EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
 }