Add VectorVerifiers to check against glm::ivecX, glm::dvecX, and glm::bvecX

include/openspace/documentation/verifier.h

@@ -79,6 +79,29 @@ struct TableVerifier : public TemplateVerifier<ghoul::Dictionary> {
     std::vector<DocumentationEntry> doc;
 };
 
+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 documentation() 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 documentation() 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 documentation() const override;
+};
+
 // Operator Verifiers
 
 template <typename T>
@@ -86,6 +109,7 @@ struct LessVerifier : public T {
     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 TableVerifier");
 
     LessVerifier(typename T::Type value);
 
@@ -101,6 +125,7 @@ struct LessEqualVerifier : public T {
     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 TableVerifier");
 
     LessEqualVerifier(typename T::Type value);
 
@@ -116,6 +141,7 @@ struct GreaterVerifier : public T {
     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 TableVerifier");
 
     GreaterVerifier(typename T::Type value);
 
@@ -131,6 +157,7 @@ struct GreaterEqualVerifier : public T {
     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 TableVerifier");
 
     GreaterEqualVerifier(typename T::Type value);
 
@@ -201,6 +228,7 @@ struct InRangeVerifier : public T {
     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 TableVerifier");
 
     InRangeVerifier(typename T::Type lower, typename T::Type upper);
 
@@ -217,6 +245,7 @@ struct NotInRangeVerifier : public T {
     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 TableVerifier");
 
     NotInRangeVerifier(typename T::Type lower, typename T::Type upper);
 
@@ -265,6 +294,16 @@ struct OrVerifier : public Verifier {
     std::shared_ptr<Verifier> b;
 };
 
+using BoolVector2Verifier = Vector2Verifier<bool>;
+using IntVector2Verifier = Vector2Verifier<int>;
+using DoubleVector2Verifier = Vector2Verifier<double>;
+using BoolVector3Verifier = Vector3Verifier<bool>;
+using IntVector3Verifier = Vector3Verifier<int>;
+using DoubleVector3Verifier = Vector3Verifier<double>;
+using BoolVector4Verifier = Vector4Verifier<bool>;
+using IntVector4Verifier = Vector4Verifier<int>;
+using DoubleVector4Verifier = Vector4Verifier<double>;
+
 using IntLessVerifier = LessVerifier<IntVerifier>;
 using DoubleLessVerifier = LessVerifier<DoubleVerifier>;
 using IntLessEqualVerifier = LessEqualVerifier<IntVerifier>;
@@ -302,6 +341,15 @@ using DoubleAnnotationVerifier = AnnotationVerifier<DoubleVerifier>;
 using StringAnnotationVerifier = AnnotationVerifier<StringVerifier>;
 using TableAnnotationVerifier = AnnotationVerifier<TableVerifier>;
 
+extern template struct Vector2Verifier<bool>;
+extern template struct Vector2Verifier<int>;
+extern template struct Vector2Verifier<double>;
+extern template struct Vector3Verifier<bool>;
+extern template struct Vector3Verifier<int>;
+extern template struct Vector3Verifier<double>;
+extern template struct Vector4Verifier<bool>;
+extern template struct Vector4Verifier<int>;
+extern template struct Vector4Verifier<double>;
 
 extern template struct LessVerifier<IntVerifier>;
 extern template struct LessVerifier<DoubleVerifier>;

include/openspace/documentation/verifier.inl

@@ -31,6 +31,42 @@ std::string to_string(std::string value);
 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);
+}
+
+template <typename T>
+std::string Vector2Verifier<T>::documentation() const {
+    using namespace std::string_literals;
+
+    return "Type: 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>::documentation() const {
+    using namespace std::string_literals;
+
+    return "Type: 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>::documentation() const {
+    using namespace std::string_literals;
+
+    return "Type: Vector4<"s + typeid(T).name() + ">";
+}
+
 template <typename T>
 LessVerifier<T>::LessVerifier(typename T::Type value) 
     : value(std::move(value))

src/documentation/verifier.cpp

@@ -27,6 +27,16 @@
 namespace openspace {
 namespace documentation {
 
+template struct Vector2Verifier<bool>;
+template struct Vector2Verifier<int>;
+template struct Vector2Verifier<double>;
+template struct Vector3Verifier<bool>;
+template struct Vector3Verifier<int>;
+template struct Vector3Verifier<double>;
+template struct Vector4Verifier<bool>;
+template struct Vector4Verifier<int>;
+template struct Vector4Verifier<double>;
+
 template struct LessVerifier<IntVerifier>;
 template struct LessVerifier<DoubleVerifier>;
 template struct LessEqualVerifier<IntVerifier>;

tests/test_documentation.inl

@@ -1752,7 +1752,7 @@ TEST_F(DocumentationTest, OrOperator) {
     };
 
     ghoul::Dictionary positive {
-        { "a", ""s}
+        { "a", ""s }
     };
     TestResult positiveRes = testSpecification(doc, positive);
     EXPECT_TRUE(positiveRes.success);
@@ -1773,3 +1773,291 @@ TEST_F(DocumentationTest, OrOperator) {
     ASSERT_EQ(1, negativeRes.offenders.size());
     EXPECT_EQ("a", negativeRes.offenders[0]);
 }
+
+TEST_F(DocumentationTest, BoolVector2Verifier) {
+    using namespace openspace::documentation;
+
+    Documentation doc {
+        "Test",
+        {{ "a", new BoolVector2Verifier }}
+    };
+
+    ghoul::Dictionary positive {
+        { "a", glm::bvec2(true) }
+    };
+    TestResult positiveRes = testSpecification(doc, positive);
+    EXPECT_TRUE(positiveRes.success);
+    EXPECT_EQ(0, positiveRes.offenders.size());
+
+    ghoul::Dictionary negative {
+        { "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]);
+
+    ghoul::Dictionary negative2 {
+        { "a", true }
+    };
+    negativeRes = testSpecification(doc, negative2);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+}
+
+TEST_F(DocumentationTest, IntVector2Verifier) {
+    using namespace openspace::documentation;
+
+    Documentation doc {
+        "Test",
+        { { "a", new IntVector2Verifier } }
+    };
+
+    ghoul::Dictionary positive {
+        { "a", glm::ivec2(2) }
+    };
+    TestResult positiveRes = testSpecification(doc, positive);
+    EXPECT_TRUE(positiveRes.success);
+    EXPECT_EQ(0, positiveRes.offenders.size());
+
+    ghoul::Dictionary negative {
+        { "a", ghoul::Dictionary{ { "1", true },{ "2", 1 } } }
+    };
+    TestResult negativeRes = testSpecification(doc, negative);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+
+    ghoul::Dictionary negative2 {
+        { "a", true }
+    };
+    negativeRes = testSpecification(doc, negative2);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+}
+
+TEST_F(DocumentationTest, DoubleVector2Verifier) {
+    using namespace openspace::documentation;
+
+    Documentation doc{
+        "Test",
+        { { "a", new DoubleVector2Verifier } }
+    };
+
+    ghoul::Dictionary positive {
+        { "a", glm::dvec2(2.0) }
+    };
+    TestResult positiveRes = testSpecification(doc, positive);
+    EXPECT_TRUE(positiveRes.success);
+    EXPECT_EQ(0, positiveRes.offenders.size());
+
+    ghoul::Dictionary negative {
+        { "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]);
+
+    ghoul::Dictionary negative2 {
+        { "a", true }
+    };
+    negativeRes = testSpecification(doc, negative2);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+}
+
+TEST_F(DocumentationTest, BoolVector3Verifier) {
+    using namespace openspace::documentation;
+
+    Documentation doc {
+        "Test",
+        { { "a", new BoolVector3Verifier } }
+    };
+
+    ghoul::Dictionary positive {
+        { "a", glm::bvec3(true) }
+    };
+    TestResult positiveRes = testSpecification(doc, positive);
+    EXPECT_TRUE(positiveRes.success);
+    EXPECT_EQ(0, positiveRes.offenders.size());
+
+    ghoul::Dictionary negative {
+        { "a", ghoul::Dictionary{ { "1", true },{ "2", 1.0 }, { "3", "s" } } }
+    };
+    TestResult negativeRes = testSpecification(doc, negative);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+
+    ghoul::Dictionary negative2 {
+        { "a", true }
+    };
+    negativeRes = testSpecification(doc, negative2);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+}
+
+TEST_F(DocumentationTest, IntVector3Verifier) {
+    using namespace openspace::documentation;
+
+    Documentation doc {
+        "Test",
+        { { "a", new IntVector3Verifier } }
+    };
+
+    ghoul::Dictionary positive {
+        { "a", glm::ivec3(2) }
+    };
+    TestResult positiveRes = testSpecification(doc, positive);
+    EXPECT_TRUE(positiveRes.success);
+    EXPECT_EQ(0, positiveRes.offenders.size());
+
+    ghoul::Dictionary negative {
+        { "a", ghoul::Dictionary{ { "1", true },{ "2", 1 }, { "3", "s" } } }
+    };
+    TestResult negativeRes = testSpecification(doc, negative);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+
+    ghoul::Dictionary negative2 {
+        { "a", true }
+    };
+    negativeRes = testSpecification(doc, negative2);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+}
+
+TEST_F(DocumentationTest, DoubleVector3Verifier) {
+    using namespace openspace::documentation;
+
+    Documentation doc {
+        "Test",
+        { { "a", new DoubleVector3Verifier } }
+    };
+
+    ghoul::Dictionary positive {
+        { "a", glm::dvec3(2.0) }
+    };
+    TestResult positiveRes = testSpecification(doc, positive);
+    EXPECT_TRUE(positiveRes.success);
+    EXPECT_EQ(0, positiveRes.offenders.size());
+
+    ghoul::Dictionary negative {
+        { "a", ghoul::Dictionary{ { "1", true },{ "2", 1.0 }, { "3", "s"} } }
+    };
+    TestResult negativeRes = testSpecification(doc, negative);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+
+    ghoul::Dictionary negative2 {
+        { "a", true }
+    };
+    negativeRes = testSpecification(doc, negative2);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+}
+
+TEST_F(DocumentationTest, BoolVector4Verifier) {
+    using namespace openspace::documentation;
+
+    Documentation doc {
+        "Test",
+        { { "a", new BoolVector4Verifier } }
+    };
+
+    ghoul::Dictionary positive {
+        { "a", glm::bvec4(true) }
+    };
+    TestResult positiveRes = testSpecification(doc, positive);
+    EXPECT_TRUE(positiveRes.success);
+    EXPECT_EQ(0, positiveRes.offenders.size());
+
+    ghoul::Dictionary negative {
+        { "a", ghoul::Dictionary{ { "1", true },{ "2", 1.0 }, { "3", "s" }, { "4", 1 }}}
+    };
+    TestResult negativeRes = testSpecification(doc, negative);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+
+    ghoul::Dictionary negative2 {
+        { "a", true }
+    };
+    negativeRes = testSpecification(doc, negative2);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+}
+
+TEST_F(DocumentationTest, IntVector4Verifier) {
+    using namespace openspace::documentation;
+
+    Documentation doc {
+        "Test",
+        { { "a", new IntVector4Verifier } }
+    };
+
+    ghoul::Dictionary positive {
+        { "a", glm::ivec4(2) }
+    };
+    TestResult positiveRes = testSpecification(doc, positive);
+    EXPECT_TRUE(positiveRes.success);
+    EXPECT_EQ(0, positiveRes.offenders.size());
+
+    ghoul::Dictionary negative {
+        { "a", ghoul::Dictionary{ { "1", true },{ "2", 1 },{ "3", "s" }, { "4", 1 } } }
+    };
+    TestResult negativeRes = testSpecification(doc, negative);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+
+    ghoul::Dictionary negative2{
+        { "a", true }
+    };
+    negativeRes = testSpecification(doc, negative2);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+}
+
+TEST_F(DocumentationTest, DoubleVector4Verifier) {
+    using namespace openspace::documentation;
+
+    Documentation doc {
+        "Test",
+        { { "a", new DoubleVector4Verifier } }
+    };
+
+    ghoul::Dictionary positive {
+        { "a", glm::dvec4(2.0) }
+    };
+    TestResult positiveRes = testSpecification(doc, positive);
+    EXPECT_TRUE(positiveRes.success);
+    EXPECT_EQ(0, positiveRes.offenders.size());
+
+    ghoul::Dictionary negative {
+        { "a", ghoul::Dictionary{ { "1", true },{ "2", 1.0 },{ "3", "s" }, { "4", 1 } } }
+    };
+    TestResult negativeRes = testSpecification(doc, negative);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+
+    ghoul::Dictionary negative2 {
+        { "a", true }
+    };
+    negativeRes = testSpecification(doc, negative2);
+    EXPECT_FALSE(negativeRes.success);
+    ASSERT_EQ(1, negativeRes.offenders.size());
+    EXPECT_EQ("a", negativeRes.offenders[0]);
+}