mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2025-12-30 15:50:55 -06:00
2818 lines
106 KiB
C++
2818 lines
106 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014-2025 *
|
|
* *
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
|
|
* software and associated documentation files (the "Software"), to deal in the Software *
|
|
* without restriction, including without limitation the rights to use, copy, modify, *
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
|
|
* permit persons to whom the Software is furnished to do so, subject to the following *
|
|
* conditions: *
|
|
* *
|
|
* The above copyright notice and this permission notice shall be included in all copies *
|
|
* or substantial portions of the Software. *
|
|
* *
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
|
|
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
|
|
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
|
|
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
|
|
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
|
|
****************************************************************************************/
|
|
|
|
#include <catch2/catch_test_macros.hpp>
|
|
|
|
#include <openspace/documentation/documentation.h>
|
|
#include <openspace/documentation/documentationengine.h>
|
|
#include <openspace/documentation/verifier.h>
|
|
#include <ghoul/filesystem/filesystem.h>
|
|
#include <ghoul/misc/dictionary.h>
|
|
#include <string>
|
|
|
|
TEST_CASE("Documentation: Constructor", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
Documentation doc;
|
|
|
|
// Basic Verifiers
|
|
doc.entries.emplace_back("BoolVerifier", new BoolVerifier);
|
|
doc.entries.emplace_back("DoubleVerifier", new DoubleVerifier);
|
|
doc.entries.emplace_back("IntVerifier", new IntVerifier);
|
|
doc.entries.emplace_back("StringVerifier", new StringVerifier);
|
|
doc.entries.emplace_back("IdentifierVerifier", new IdentifierVerifier);
|
|
doc.entries.emplace_back("FileVerifier", new FileVerifier);
|
|
doc.entries.emplace_back("DirectoryVerifier", new DirectoryVerifier);
|
|
doc.entries.emplace_back("DateTimeVerifier", new DateTimeVerifier);
|
|
doc.entries.emplace_back("TableVerifier", new TableVerifier);
|
|
|
|
// Operator Verifiers
|
|
doc.entries.emplace_back("LessDouble", new DoubleLessVerifier(0.0));
|
|
doc.entries.emplace_back("LessInt", new IntLessVerifier(0));
|
|
doc.entries.emplace_back("LessEqualDouble", new DoubleLessEqualVerifier(0.0));
|
|
doc.entries.emplace_back("LessEqualInt", new IntLessEqualVerifier(0));
|
|
|
|
doc.entries.emplace_back("GreaterDouble", new DoubleGreaterVerifier(0.0));
|
|
doc.entries.emplace_back("GreaterInt", new IntGreaterVerifier(0));
|
|
|
|
doc.entries.emplace_back("GreaterEqualDouble", new DoubleGreaterEqualVerifier(0.0));
|
|
doc.entries.emplace_back("GreaterEqualInt", new IntGreaterEqualVerifier(0));
|
|
|
|
doc.entries.emplace_back("EqualBool", new BoolEqualVerifier(false));
|
|
doc.entries.emplace_back("EqualDouble", new DoubleEqualVerifier(0.0));
|
|
doc.entries.emplace_back("EqualInt", new IntEqualVerifier(0));
|
|
doc.entries.emplace_back("EqualString", new StringEqualVerifier(""));
|
|
|
|
doc.entries.emplace_back("UnequalBool", new BoolUnequalVerifier(false));
|
|
doc.entries.emplace_back("UnequalDouble", new DoubleUnequalVerifier(0.0));
|
|
doc.entries.emplace_back("UnequalInt", new IntUnequalVerifier(0));
|
|
doc.entries.emplace_back("UnequalString", new StringUnequalVerifier(""));
|
|
|
|
// List Verifiers
|
|
doc.entries.emplace_back("InListBool", new BoolInListVerifier({ true, false }));
|
|
doc.entries.emplace_back("InListDouble", new DoubleInListVerifier({ 0.0, 1.0 }));
|
|
doc.entries.emplace_back("InListInt", new IntInListVerifier({ 0, 1 }));
|
|
doc.entries.emplace_back("InListString", new StringInListVerifier({ "", "a" }));
|
|
|
|
doc.entries.emplace_back("NotInListBool", new BoolNotInListVerifier({ true, false }));
|
|
doc.entries.emplace_back(
|
|
"NotInListDouble",
|
|
new DoubleNotInListVerifier({ 0.0, 1.0 })
|
|
);
|
|
doc.entries.emplace_back("NotInListInt", new IntNotInListVerifier({ 0, 1 }));
|
|
doc.entries.emplace_back("NotInListString", new StringNotInListVerifier({ "", "a" }));
|
|
|
|
doc.entries.emplace_back("StringListVerifier", new StringListVerifier);
|
|
doc.entries.emplace_back("IntListVerifier", new IntListVerifier);
|
|
|
|
// Range Verifiers
|
|
doc.entries.emplace_back("InListDouble", new DoubleInRangeVerifier(0.0, 1.0));
|
|
doc.entries.emplace_back("InListInt", new IntInRangeVerifier(0, 1));
|
|
|
|
doc.entries.emplace_back("NotInListDouble", new DoubleNotInRangeVerifier(0.0, 1.0));
|
|
doc.entries.emplace_back("NotInListInt", new IntNotInRangeVerifier(0, 1));
|
|
|
|
// Misc Verifiers
|
|
doc.entries.emplace_back("AnnotationBool", new BoolAnnotationVerifier("Bool"));
|
|
doc.entries.emplace_back("AnnotationDouble", new DoubleAnnotationVerifier("Double"));
|
|
doc.entries.emplace_back("AnnotationInt", new IntAnnotationVerifier("Int"));
|
|
doc.entries.emplace_back("AnnotationString", new StringAnnotationVerifier("String"));
|
|
doc.entries.emplace_back("AnnotationTable", new TableAnnotationVerifier("Table"));
|
|
}
|
|
|
|
TEST_CASE("Documentation: Initializer Constructor", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {
|
|
// Basic Verifiers
|
|
{ "BoolVerifier", new BoolVerifier },
|
|
{ "DoubleVerifier", new DoubleVerifier },
|
|
{ "IntVerifier", new IntVerifier },
|
|
{ "StringVerifier", new StringVerifier },
|
|
{ "IdentifierVerifier", new IdentifierVerifier },
|
|
{ "FileVerifier", new FileVerifier },
|
|
{ "DirectoryVerifier", new DirectoryVerifier },
|
|
{ "DateTimeVerifier", new DateTimeVerifier },
|
|
{ "TableVerifier", new TableVerifier },
|
|
|
|
// Operator Verifiers
|
|
{ "LessDouble", new DoubleLessVerifier(0.0) },
|
|
{ "LessInt", new IntLessVerifier(0) },
|
|
|
|
{ "LessEqualDouble", new DoubleLessEqualVerifier(0.0) },
|
|
{ "LessEqualInt", new IntLessEqualVerifier(0) },
|
|
|
|
{ "GreaterDouble", new DoubleGreaterVerifier(0.0) },
|
|
{ "GreaterInt", new IntGreaterVerifier(0) },
|
|
|
|
{ "GreaterEqualDouble", new DoubleGreaterEqualVerifier(0.0) },
|
|
{ "GreaterEqualInt", new IntGreaterEqualVerifier(0) },
|
|
|
|
{ "EqualBool", new BoolEqualVerifier(false) },
|
|
{ "EqualDouble", new DoubleEqualVerifier(0.0) },
|
|
{ "EqualInt", new IntEqualVerifier(0) },
|
|
{ "EqualString", new StringEqualVerifier("") },
|
|
|
|
{ "UnequalBool", new BoolUnequalVerifier(false) },
|
|
{ "UnequalDouble", new DoubleUnequalVerifier(0.0) },
|
|
{ "UnequalInt", new IntUnequalVerifier(0) },
|
|
{ "UnequalString", new StringUnequalVerifier("") },
|
|
|
|
// List Verifiers
|
|
{ "InListBool", new BoolInListVerifier({ true, false }) },
|
|
{ "InListDouble", new DoubleInListVerifier({ 0.0, 1.0 }) },
|
|
{ "InListInt", new IntInListVerifier({ 0, 1 }) },
|
|
{ "InListString", new StringInListVerifier({ "", "a" }) },
|
|
|
|
{ "NotInListBool", new BoolNotInListVerifier({ true, false }) },
|
|
{ "NotInListDouble", new DoubleNotInListVerifier({ 0.0, 1.0 }) },
|
|
{ "NotInListInt", new IntNotInListVerifier({ 0, 1 }) },
|
|
{ "NotInListString", new StringNotInListVerifier({ "", "a" }) },
|
|
|
|
// Range Verifiers
|
|
{ "InRangeDouble", new DoubleInRangeVerifier(0.0, 1.0) },
|
|
{ "InRangeInt", new IntInRangeVerifier(0, 1) },
|
|
|
|
{ "InRangeDouble", new DoubleNotInRangeVerifier(0.0, 1.0) },
|
|
{ "InRangeInt", new IntNotInRangeVerifier(0, 1) },
|
|
|
|
// Misc Verifiers
|
|
{ "AnnotationBool", new BoolAnnotationVerifier("Bool") },
|
|
{ "AnnotationDouble", new DoubleAnnotationVerifier("Double") },
|
|
{ "AnnotationInt", new IntAnnotationVerifier("Int") },
|
|
{ "AnnotationString", new StringAnnotationVerifier("String") },
|
|
{ "AnnotationTable", new TableAnnotationVerifier("Table") }
|
|
}
|
|
};
|
|
}
|
|
|
|
TEST_CASE("Documentation: BoolVerifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Bool", new BoolVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Bool", true);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("Bool", 0);
|
|
TestResult negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Bool");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeExist;
|
|
negativeExist.setValue("Bool2", 0);
|
|
negativeRes = testSpecification(doc, negativeExist);
|
|
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Bool");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleVerifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new DoubleVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", 0.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("Double", 0);
|
|
TestResult negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeExist;
|
|
negativeExist.setValue("Double2", 0.0);
|
|
negativeRes = testSpecification(doc, negativeExist);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: IntVerifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("Int", 0.0);
|
|
positiveRes = testSpecification(doc, positive2);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("Int", 0.1);
|
|
TestResult negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeExist;
|
|
negativeExist.setValue("Int2", 0);
|
|
negativeRes = testSpecification(doc, negativeExist);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: StringVerifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "String", new StringVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("String", ""s);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("String", 0);
|
|
TestResult negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "String");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeExist;
|
|
negativeExist.setValue("String2", ""s);
|
|
negativeRes = testSpecification(doc, negativeExist);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "String");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: IdentifierVerifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Identifier", new IdentifierVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Identifier", "abcdef"s);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negativeSpace;
|
|
negativeSpace.setValue("Identifier", "abc def"s);
|
|
TestResult negativeRes = testSpecification(doc, negativeSpace);
|
|
CHECK(!negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Identifier");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negativeTab;
|
|
negativeTab.setValue("Identifier", "abc\tdef"s);
|
|
negativeRes = testSpecification(doc, negativeTab);
|
|
CHECK(!negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Identifier");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negativeNewline;
|
|
negativeNewline.setValue("Identifier", "abc\ndef"s);
|
|
negativeRes = testSpecification(doc, negativeNewline);
|
|
CHECK(!negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Identifier");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negativeCarriageReturn;
|
|
negativeCarriageReturn.setValue("Identifier", "abc\rdef"s);
|
|
negativeRes = testSpecification(doc, negativeCarriageReturn);
|
|
CHECK(!negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Identifier");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negativeDot;
|
|
negativeDot.setValue("Identifier", "abc.def"s);
|
|
negativeRes = testSpecification(doc, negativeDot);
|
|
CHECK(!negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Identifier");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("Identifier", 0);
|
|
negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Identifier");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: FileVerifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "File", new FileVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("File", absPath("${TESTDIR}/verifier/dummyfile.txt"));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative404;
|
|
negative404.setValue("File", absPath("${TESTDIR}/verifier/404.txt"));
|
|
TestResult negativeRes = testSpecification(doc, negative404);
|
|
CHECK(!negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "File");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("File", 0);
|
|
negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "File");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeExist;
|
|
negativeExist.setValue("File2", ""s);
|
|
negativeRes = testSpecification(doc, negativeExist);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "File");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DirectoryVerifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Dir", new DirectoryVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Dir", absPath("${TESTDIR}/verifier"));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative404;
|
|
negative404.setValue("Dir", absPath("${TESTDIR}/verifier404"));
|
|
TestResult negativeRes = testSpecification(doc, negative404);
|
|
CHECK(!negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Dir");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("Dir", 0);
|
|
negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Dir");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeExist;
|
|
negativeExist.setValue("Dir2", ""s);
|
|
negativeRes = testSpecification(doc, negativeExist);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Dir");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DateTimeVerifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "DateTime", new DateTimeVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("DateTime", "1969 07 20 20:17:00"s);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative404;
|
|
negative404.setValue("DateTime", "abc"s);
|
|
TestResult negativeRes = testSpecification(doc, negative404);
|
|
CHECK(!negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "DateTime");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("DateTime", 0);
|
|
negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "DateTime");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeExist;
|
|
negativeExist.setValue("DateTime2", ""s);
|
|
negativeRes = testSpecification(doc, negativeExist);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "DateTime");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: TableVerifierType", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Table", new TableVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Table", ghoul::Dictionary());
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("Table", 0);
|
|
TestResult negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Table");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeExist;
|
|
negativeExist.setValue("Table2", ghoul::Dictionary());
|
|
negativeRes = testSpecification(doc, negativeExist);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Table");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: StringListVerifierType", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "StringList", new StringListVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", "a"s);
|
|
inner.setValue("2", "b"s);
|
|
inner.setValue("3", "c"s);
|
|
positive.setValue("StringList", inner);
|
|
}
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("StringList", 0);
|
|
TestResult negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "StringList");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
|
|
ghoul::Dictionary negative2;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", "a"s);
|
|
inner.setValue("2", "b"s);
|
|
inner.setValue("3", 2.0);
|
|
negative2.setValue("StringList", inner);
|
|
}
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "StringList.3");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeExist;
|
|
negativeExist.setValue("StringList2", ghoul::Dictionary());
|
|
negativeRes = testSpecification(doc, negativeExist);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "StringList");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: IntListVerifierType", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "IntList", new IntListVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", 1);
|
|
inner.setValue("2", 2);
|
|
inner.setValue("3", 3);
|
|
positive.setValue("IntList", inner);
|
|
}
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negativeType;
|
|
negativeType.setValue("IntList", 0);
|
|
TestResult negativeRes = testSpecification(doc, negativeType);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "IntList");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", "a"s);
|
|
inner.setValue("2", 1);
|
|
inner.setValue("3", 2);
|
|
negative2.setValue("IntList", inner);
|
|
}
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "IntList.1");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeExist;
|
|
negativeExist.setValue("IntList2", ghoul::Dictionary());
|
|
negativeRes = testSpecification(doc, negativeExist);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "IntList");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: MixedVerifiers", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {
|
|
{ "Bool", new BoolVerifier },
|
|
{ "Double", new DoubleVerifier },
|
|
{ "Int", new IntVerifier },
|
|
{ "String", new StringVerifier },
|
|
{ "Table", new TableVerifier }
|
|
}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Bool", true);
|
|
positive.setValue("Double", 0.0);
|
|
positive.setValue("Int", 0);
|
|
positive.setValue("String", ""s);
|
|
positive.setValue("Table", ghoul::Dictionary());
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negativeType1;
|
|
negativeType1.setValue("Bool", true);
|
|
negativeType1.setValue("Double", 1);
|
|
negativeType1.setValue("Int", 0);
|
|
negativeType1.setValue("String", ""s);
|
|
negativeType1.setValue("Table", ghoul::Dictionary());
|
|
TestResult negativeRes = testSpecification(doc, negativeType1);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeType2;
|
|
negativeType2.setValue("Bool", true);
|
|
negativeType2.setValue("Double", 0.0);
|
|
negativeType2.setValue("Int", ""s);
|
|
negativeType2.setValue("String", 1);
|
|
negativeType2.setValue("Table", ghoul::Dictionary());
|
|
negativeRes = testSpecification(doc, negativeType2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 2);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[1].offender == "String");
|
|
CHECK(negativeRes.offenses[1].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: NestedTables", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {
|
|
{ "Outer_Int", new IntVerifier },
|
|
{
|
|
"Outer_Table",
|
|
new TableVerifier({
|
|
{ "Inner_Double", new DoubleVerifier },
|
|
{ "Inner_String", new StringVerifier }
|
|
})
|
|
},
|
|
{ "Outer_Double", new DoubleVerifier },
|
|
{
|
|
"Outer_Table2",
|
|
new TableVerifier({
|
|
{ "Inner_Double2", new DoubleVerifier },
|
|
{ "Inner_String2", new StringVerifier },
|
|
{
|
|
"Inner_Table",
|
|
new TableVerifier({
|
|
{ "Inner_Inner_Int", new IntVerifier }
|
|
})
|
|
}
|
|
})
|
|
}
|
|
}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Outer_Int", 1);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double", 0.0);
|
|
inner.setValue("Inner_String", ""s);
|
|
positive.setValue("Outer_Table", inner);
|
|
}
|
|
positive.setValue("Outer_Double", 0.0);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double2", 0.0);
|
|
inner.setValue("Inner_String2", ""s);
|
|
{
|
|
ghoul::Dictionary innerInner;
|
|
innerInner.setValue("Inner_Inner_Int", 0);
|
|
inner.setValue("Inner_Table", innerInner);
|
|
}
|
|
positive.setValue("Outer_Table2", inner);
|
|
}
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negativeSimple;
|
|
negativeSimple.setValue("Outer_Int", 1);
|
|
negativeSimple.setValue("Outer_Table", 0);
|
|
negativeSimple.setValue("Outer_Double", 0.0);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double2", 0.0);
|
|
inner.setValue("Inner_String2", ""s);
|
|
{
|
|
ghoul::Dictionary innerInner;
|
|
innerInner.setValue("Inner_Inner_Int", 0);
|
|
inner.setValue("Inner_Table", innerInner);
|
|
}
|
|
negativeSimple.setValue("Outer_Table2", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negativeSimple);
|
|
CHECK_FALSE(negativeRes.success);
|
|
CHECK(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Outer_Table");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeInner;
|
|
negativeInner.setValue("Outer_Int", 1);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double", ""s);
|
|
inner.setValue("Inner_String", ""s);
|
|
negativeInner.setValue("Outer_Table", inner);
|
|
}
|
|
negativeInner.setValue("Outer_Double", 0.0);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double2", 0.0);
|
|
inner.setValue("Inner_String2", ""s);
|
|
{
|
|
ghoul::Dictionary innerInner;
|
|
innerInner.setValue("Inner_Inner_Int", 0);
|
|
inner.setValue("Inner_Table", innerInner);
|
|
}
|
|
negativeInner.setValue("Outer_Table2", inner);
|
|
}
|
|
negativeRes = testSpecification(doc, negativeInner);
|
|
CHECK_FALSE(negativeRes.success);
|
|
CHECK(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Outer_Table.Inner_Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeInner2;
|
|
negativeInner2.setValue("Outer_Int", 1);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double", ""s);
|
|
inner.setValue("Inner_String", 0.0);
|
|
negativeInner2.setValue("Outer_Table", inner);
|
|
}
|
|
negativeInner2.setValue("Outer_Double", 0.0);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double2", 0.0);
|
|
inner.setValue("Inner_String2", ""s);
|
|
{
|
|
ghoul::Dictionary innerInner;
|
|
innerInner.setValue("Inner_Inner_Int", 0);
|
|
inner.setValue("Inner_Table", innerInner);
|
|
}
|
|
negativeInner2.setValue("Outer_Table2", inner);
|
|
}
|
|
negativeRes = testSpecification(doc, negativeInner2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
CHECK(negativeRes.offenses.size() == 2);
|
|
CHECK(negativeRes.offenses[0].offender == "Outer_Table.Inner_Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[1].offender == "Outer_Table.Inner_String");
|
|
CHECK(negativeRes.offenses[1].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeInnerSeparate;
|
|
negativeInnerSeparate.setValue("Outer_Int", 1);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double", ""s);
|
|
inner.setValue("Inner_String", ""s);
|
|
negativeInnerSeparate.setValue("Outer_Table", inner);
|
|
}
|
|
negativeInnerSeparate.setValue("Outer_Double", 0.0);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double2", ""s);
|
|
inner.setValue("Inner_String2", ""s);
|
|
{
|
|
ghoul::Dictionary innerInner;
|
|
innerInner.setValue("Inner_Inner_Int", 0);
|
|
inner.setValue("Inner_Table", innerInner);
|
|
}
|
|
negativeInnerSeparate.setValue("Outer_Table2", inner);
|
|
}
|
|
negativeRes = testSpecification(doc, negativeInnerSeparate);
|
|
CHECK_FALSE(negativeRes.success);
|
|
CHECK(negativeRes.offenses.size() == 2);
|
|
CHECK(negativeRes.offenses[0].offender == "Outer_Table.Inner_Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[1].offender == "Outer_Table2.Inner_Double2");
|
|
CHECK(negativeRes.offenses[1].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negativeInnerFull;
|
|
negativeInnerFull.setValue("Outer_Int", 1);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double", ""s);
|
|
inner.setValue("Inner_String", ""s);
|
|
negativeInnerFull.setValue("Outer_Table", inner);
|
|
}
|
|
negativeInnerFull.setValue("Outer_Double", 0.0);
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("Inner_Double2", ""s);
|
|
inner.setValue("Inner_String2", ""s);
|
|
{
|
|
ghoul::Dictionary innerInner;
|
|
innerInner.setValue("Inner_Inner_Int", ""s);
|
|
inner.setValue("Inner_Table", innerInner);
|
|
}
|
|
negativeInnerFull.setValue("Outer_Table2", inner);
|
|
}
|
|
negativeRes = testSpecification(doc, negativeInnerFull);
|
|
CHECK_FALSE(negativeRes.success);
|
|
CHECK(negativeRes.offenses.size() == 3);
|
|
CHECK(negativeRes.offenses[0].offender == "Outer_Table.Inner_Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[1].offender == "Outer_Table2.Inner_Double2");
|
|
CHECK(negativeRes.offenses[1].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[2].offender == "Outer_Table2.Inner_Table.Inner_Inner_Int");
|
|
CHECK(negativeRes.offenses[2].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Optional", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {
|
|
{ "Bool_Force", new BoolVerifier },
|
|
{ "Bool_Optional", new BoolVerifier, Optional::Yes }
|
|
}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Bool_Force", true);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("Bool_Force", true);
|
|
positive2.setValue("Bool_Optional", true);
|
|
positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
const ghoul::Dictionary negative;
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Bool_Force");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("Bool_Optional", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Bool_Force");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
|
|
ghoul::Dictionary negative3;
|
|
negative3.setValue("Bool_Force", true);
|
|
negative3.setValue("Bool_Optional", 1);
|
|
negativeRes = testSpecification(doc, negative3);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Bool_Optional");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Required In Optional", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {
|
|
{
|
|
"a",
|
|
new TableVerifier({
|
|
{ "b", new IntVerifier },
|
|
{ "c", new IntVerifier, Optional::Yes }
|
|
}),
|
|
Optional::Yes
|
|
}
|
|
}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("b", 1);
|
|
positive.setValue("a", inner);
|
|
}
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("b", 1);
|
|
inner.setValue("c", 2);
|
|
positive2.setValue("a", inner);
|
|
}
|
|
positiveRes = testSpecification(doc, positive2);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
const ghoul::Dictionary positive3;
|
|
positiveRes = testSpecification(doc, positive3);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("c", 2);
|
|
negative.setValue("a", inner);
|
|
}
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a.b");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Exhaustive", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 1);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("False_Int", 1);
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("Double", 2.0);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Nested Exhaustive", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Table", new TableVerifier({{ "a", new IntVerifier }}) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("a", 1);
|
|
positive.setValue("Table", inner);
|
|
}
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("b", 2.0);
|
|
negative.setValue("Table", inner);
|
|
}
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Table.a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::MissingKey);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Empty Entries Non Exhaustive", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc;
|
|
|
|
const ghoul::Dictionary positive {};
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("a", 1);
|
|
positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
}
|
|
|
|
TEST_CASE("Documentation: Empty Nested Exhaustive", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Table", new TableVerifier() }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Table", ghoul::Dictionary());
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("a", 1);
|
|
negative.setValue("Table", inner);
|
|
}
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK(negativeRes.success);
|
|
CHECK(negativeRes.offenses.empty());
|
|
}
|
|
|
|
TEST_CASE("Documentation: Less Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntLessVerifier(5) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 0.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 10.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Less Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new DoubleLessVerifier(5.0) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", 0.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", 10.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: LessEqual Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntLessEqualVerifier(5) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 0.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positiveEqual;
|
|
positiveEqual.setValue("Int", 5.0);
|
|
positiveRes = testSpecification(doc, positiveEqual);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 10.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: LessEqual Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new DoubleLessEqualVerifier(5.0) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", 0.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positiveEqual;
|
|
positiveEqual.setValue("Double", 5.0);
|
|
positiveRes = testSpecification(doc, positiveEqual);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", 10.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Greater Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntGreaterVerifier(5) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 10.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 0.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Greater Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new DoubleGreaterVerifier(5.0) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", 10.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", 0.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: GreaterEqual Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntGreaterEqualVerifier(5) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 10.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positiveEqual;
|
|
positiveEqual.setValue("Int", 5.0);
|
|
positiveRes = testSpecification(doc, positiveEqual);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 0.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: GreaterEqual Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new DoubleGreaterEqualVerifier(5.0) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", 10.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positiveEqual;
|
|
positiveEqual.setValue("Double", 5.0);
|
|
positiveRes = testSpecification(doc, positiveEqual);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", 0.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Equal Bool", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Bool", new BoolEqualVerifier(true) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Bool", true);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Bool", false);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Bool");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Equal Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntEqualVerifier(1) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 1.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 0.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Equal Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new DoubleEqualVerifier(1.0) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", 1.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", 0.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Equal String", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "String", new StringEqualVerifier("string"s) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("String", "string"s);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("String", "no_string"s);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "String");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Unequal Bool", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Bool", new BoolUnequalVerifier(true) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Bool", false);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Bool", true);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Bool");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Unequal Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntUnequalVerifier(1) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 0.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 1.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Unequal Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new DoubleUnequalVerifier(1.0) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", 0.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", 1.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Unequal String", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "String", new StringUnequalVerifier("string"s) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("String", "no_string"s);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("String", "string"s);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "String");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: List Bool", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Bool", new BoolInListVerifier({ true }) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Bool", true);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Bool", false);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Bool");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: List Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntInListVerifier({ 0, 1, 2 }) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 1.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("Int", 2.0);
|
|
positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 5.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: List Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new DoubleInListVerifier({ 0.0, 1.0, 2.0 }) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", 1.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("Double", 2.0);
|
|
positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", 5.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: List String", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "String", new StringInListVerifier({ "0"s, "1"s, "2"s }) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("String", "1"s);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("String", "2"s);
|
|
positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("String", "5"s);
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "String");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: NotList Bool", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Bool", new BoolNotInListVerifier({ true }) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Bool", false);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Bool", true);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Bool");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: NotList Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntNotInListVerifier({ 0, 1, 2 }) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", -1.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("Int", 3.0);
|
|
positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 2.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: NotList Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new DoubleNotInListVerifier({ 0.0, 1.0, 2.0 }) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", -1.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("Double", 3.0);
|
|
positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", 1.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: NotList String", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "String", new StringNotInListVerifier({ "0"s, "1"s, "2"s }) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("String", "string"s);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("String", "foo_string"s);
|
|
positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("String", "1"s);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "String");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Annotation Bool", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Bool", new BoolAnnotationVerifier("Bool") }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Bool", true);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Bool", 0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Bool");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Annotation Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new IntAnnotationVerifier("Int") }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 1.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 1.1);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Annotation Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new DoubleAnnotationVerifier("Double") }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", 0.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", true);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Annotation String", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "String", new StringAnnotationVerifier("String") }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("String", ""s);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("String", 1);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "String");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Annotation Table", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Table", new TableAnnotationVerifier("Table") }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Table", ghoul::Dictionary());
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Table", 1);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Table");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: InRange Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new InRangeVerifier<IntVerifier>(0, 5) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", 2.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("Int", 0.0);
|
|
positiveRes = testSpecification(doc, positive2);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive3;
|
|
positive3.setValue("Int", 5.0);
|
|
positiveRes = testSpecification(doc, positive3);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 10.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: InRange Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new InRangeVerifier<DoubleVerifier>(0.0, 5.0) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", 2.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("Double", 0.0);
|
|
positiveRes = testSpecification(doc, positive2);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive3;
|
|
positive3.setValue("Double", 5.0);
|
|
positiveRes = testSpecification(doc, positive3);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive4;
|
|
positive4.setValue("Double", 1.5);
|
|
positiveRes = testSpecification(doc, positive4);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", 10.0);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: NotInRange Int", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Int", new NotInRangeVerifier<IntVerifier>(0, 5) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Int", -1.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("Int", 6.0);
|
|
positiveRes = testSpecification(doc, positive2);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Int", 2.0);
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("Int", 0.0);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negative3;
|
|
negative3.setValue("Int", 5.0);
|
|
negativeRes = testSpecification(doc, negative3);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Int");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: NotInRange Double", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Double", new NotInRangeVerifier<DoubleVerifier>(0.0, 5.0) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("Double", -1.0);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("Double", 6.0);
|
|
positiveRes = testSpecification(doc, positive2);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Double", 0.0);
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("Double", 5.0);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negative3;
|
|
negative3.setValue("Double", 2.5);
|
|
negativeRes = testSpecification(doc, negative3);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Double");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::Verification);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Wildcard", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ DocumentationEntry::Wildcard, new IntVerifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", 1);
|
|
positive.setValue("b", 2);
|
|
positive.setValue("c", 3);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("a", false);
|
|
negative.setValue("b", 2);
|
|
negative.setValue("c", 3);
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", false);
|
|
negative2.setValue("b", false);
|
|
negative2.setValue("c", 3);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 2);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[1].offender == "b");
|
|
CHECK(negativeRes.offenses[1].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative3;
|
|
negative3.setValue("a", false);
|
|
negative3.setValue("b", false);
|
|
negative3.setValue("c", false);
|
|
negativeRes = testSpecification(doc, negative3);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 3);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[1].offender == "b");
|
|
CHECK(negativeRes.offenses[1].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[2].offender == "c");
|
|
CHECK(negativeRes.offenses[2].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Wildcard Mixed", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {
|
|
{ DocumentationEntry::Wildcard, new IntVerifier },
|
|
{ "b", new IntGreaterVerifier(5) }
|
|
}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", 1.0);
|
|
positive.setValue("b", 8.0);
|
|
positive.setValue("c", 3.0);
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("a", false);
|
|
negative.setValue("b", 2.0);
|
|
negative.setValue("c", 3.0);
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 2);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[1].offender == "b");
|
|
CHECK(negativeRes.offenses[1].reason == TestResult::Offense::Reason::Verification);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", false);
|
|
negative2.setValue("b", false);
|
|
negative2.setValue("c", 3.0);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 2);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[1].offender == "b");
|
|
CHECK(negativeRes.offenses[1].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative3;
|
|
negative3.setValue("a", false);
|
|
negative3.setValue("b", 1.0);
|
|
negative3.setValue("c", false);
|
|
negativeRes = testSpecification(doc, negative3);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 3);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[1].offender == "b");
|
|
CHECK(negativeRes.offenses[1].reason == TestResult::Offense::Reason::Verification);
|
|
CHECK(negativeRes.offenses[2].offender == "c");
|
|
CHECK(negativeRes.offenses[2].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative4;
|
|
negative4.setValue("a", false);
|
|
negative4.setValue("b", 10.0);
|
|
negative4.setValue("c", false);
|
|
negativeRes = testSpecification(doc, negative4);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 2);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
CHECK(negativeRes.offenses[1].offender == "c");
|
|
CHECK(negativeRes.offenses[1].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Referencing", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation referenced = {
|
|
"Referenced Name",
|
|
"referenced_id",
|
|
"",
|
|
{{ "a", new IntVerifier }, { "b", new DoubleVerifier }},
|
|
};
|
|
DocEng.addDocumentation(referenced);
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "Table", new ReferencingVerifier("referenced_id") }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("a", 1);
|
|
inner.setValue("b", 2.0);
|
|
positive.setValue("Table", inner);
|
|
}
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("Table", 1);
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Table");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("a", 1);
|
|
inner.setValue("b", true);
|
|
negative2.setValue("Table", inner);
|
|
}
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Table.b");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
|
|
const Documentation wrongDoc = {
|
|
.entries = {{ "Table", new ReferencingVerifier("WRONG") }}
|
|
};
|
|
ghoul::Dictionary wrongNegative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("a", 1);
|
|
inner.setValue("b", 2.0);
|
|
wrongNegative.setValue("Table", inner);
|
|
}
|
|
negativeRes = testSpecification(wrongDoc, wrongNegative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "Table");
|
|
CHECK(
|
|
negativeRes.offenses[0].reason == TestResult::Offense::Reason::UnknownIdentifier
|
|
);
|
|
}
|
|
|
|
TEST_CASE("Documentation: OrOperator", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new OrVerifier({ new StringVerifier, new IntVerifier }) }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", ""s);
|
|
TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary positive2;
|
|
positive2.setValue("a", 1);
|
|
positiveRes = testSpecification(doc, positive2);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
negative.setValue("a", false);
|
|
const TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: IntVector2Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new IntVector2Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::ivec2(2));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleVector2Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleVector2Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dvec2(2.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: IntVector3Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new IntVector3Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::ivec3(2));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleVector3Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleVector3Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dvec3(2.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: IntVector4Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new IntVector4Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::ivec4(2));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1);
|
|
inner.setValue("3", "s"s);
|
|
inner.setValue("4", 1);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleVector4Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleVector4Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dvec4(2.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
inner.setValue("4", 1);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleMatrix2x2Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleMatrix2x2Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dmat2x2(1.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleMatrix2x3Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleMatrix2x3Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dmat2x3(1.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleMatrix2x4Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleMatrix2x4Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dmat2x4(1.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleMatrix3x2Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleMatrix3x2Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dmat3x2(1.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleMatrix3x3Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleMatrix3x3Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dmat3x3(1.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleMatrix3x4Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleMatrix3x4Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dmat3x4(1.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleMatrix4x2Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleMatrix4x2Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dmat4x2(1.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleMatrix4x3Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleMatrix4x3Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dmat4x3(1.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: DoubleMatrix4x4Verifier", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
const Documentation doc = {
|
|
.entries = {{ "a", new DoubleMatrix4x4Verifier }}
|
|
};
|
|
|
|
ghoul::Dictionary positive;
|
|
positive.setValue("a", glm::dmat4x4(1.0));
|
|
const TestResult positiveRes = testSpecification(doc, positive);
|
|
CHECK(positiveRes.success);
|
|
CHECK(positiveRes.offenses.empty());
|
|
|
|
ghoul::Dictionary negative;
|
|
{
|
|
ghoul::Dictionary inner;
|
|
inner.setValue("1", true);
|
|
inner.setValue("2", 1.0);
|
|
inner.setValue("3", "s"s);
|
|
negative.setValue("a", inner);
|
|
}
|
|
TestResult negativeRes = testSpecification(doc, negative);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
|
|
ghoul::Dictionary negative2;
|
|
negative2.setValue("a", true);
|
|
negativeRes = testSpecification(doc, negative2);
|
|
CHECK_FALSE(negativeRes.success);
|
|
REQUIRE(negativeRes.offenses.size() == 1);
|
|
CHECK(negativeRes.offenses[0].offender == "a");
|
|
CHECK(negativeRes.offenses[0].reason == TestResult::Offense::Reason::WrongType);
|
|
}
|
|
|
|
TEST_CASE("Documentation: Verifier Type Post Conditions", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
CHECK(!BoolVerifier().type().empty());
|
|
CHECK(!DoubleVerifier().type().empty());
|
|
CHECK(!IntVerifier().type().empty());
|
|
CHECK(!StringVerifier().type().empty());
|
|
CHECK(!TableVerifier().type().empty());
|
|
|
|
CHECK(!IntVector2Verifier().type().empty());
|
|
CHECK(!DoubleVector2Verifier().type().empty());
|
|
CHECK(!IntVector3Verifier().type().empty());
|
|
CHECK(!DoubleVector3Verifier().type().empty());
|
|
CHECK(!IntVector4Verifier().type().empty());
|
|
CHECK(!DoubleVector4Verifier().type().empty());
|
|
|
|
CHECK(!IntLessVerifier(0).type().empty());
|
|
CHECK(!DoubleLessVerifier(0.0).type().empty());
|
|
CHECK(!IntLessEqualVerifier(0).type().empty());
|
|
CHECK(!DoubleLessEqualVerifier(0.0).type().empty());
|
|
CHECK(!IntGreaterVerifier(0).type().empty());
|
|
CHECK(!DoubleGreaterVerifier(0.0).type().empty());
|
|
CHECK(!IntGreaterEqualVerifier(0).type().empty());
|
|
CHECK(!DoubleGreaterEqualVerifier(0.0).type().empty());
|
|
|
|
CHECK(!BoolEqualVerifier(true).type().empty());
|
|
CHECK(!IntEqualVerifier(0).type().empty());
|
|
CHECK(!DoubleEqualVerifier(0.0).type().empty());
|
|
CHECK(!StringEqualVerifier(""s).type().empty());
|
|
CHECK(!BoolUnequalVerifier(true).type().empty());
|
|
CHECK(!IntUnequalVerifier(0).type().empty());
|
|
CHECK(!DoubleUnequalVerifier(0.0).type().empty());
|
|
CHECK(!StringUnequalVerifier(""s).type().empty());
|
|
|
|
CHECK(!BoolInListVerifier({ true }).type().empty());
|
|
CHECK(!IntInListVerifier({ 0 }).type().empty());
|
|
CHECK(!DoubleInListVerifier({ 0.0 }).type().empty());
|
|
CHECK(!StringInListVerifier({ ""s }).type().empty());
|
|
CHECK(!BoolNotInListVerifier({ true }).type().empty());
|
|
CHECK(!IntNotInListVerifier({ 0 }).type().empty());
|
|
CHECK(!DoubleNotInListVerifier({ 0.0 }).type().empty());
|
|
CHECK(!StringNotInListVerifier({ ""s }).type().empty());
|
|
|
|
CHECK(!IntInRangeVerifier(0, 1).type().empty());
|
|
CHECK(!DoubleInRangeVerifier(0.0, 1.0).type().empty());
|
|
CHECK(!IntNotInRangeVerifier(0, 1).type().empty());
|
|
CHECK(!DoubleNotInRangeVerifier(0.0, 1.0).type().empty());
|
|
|
|
CHECK(!BoolAnnotationVerifier("A"s).type().empty());
|
|
CHECK(!IntAnnotationVerifier("A"s).type().empty());
|
|
CHECK(!DoubleAnnotationVerifier("A"s).type().empty());
|
|
CHECK(!StringAnnotationVerifier("A"s).type().empty());
|
|
CHECK(!TableAnnotationVerifier("A"s).type().empty());
|
|
CHECK(!AnnotationVerifier<IntVector2Verifier>("A"s).type().empty());
|
|
CHECK(!AnnotationVerifier<DoubleVector2Verifier>("A"s).type().empty());
|
|
CHECK(!AnnotationVerifier<IntVector3Verifier>("A"s).type().empty());
|
|
CHECK(!AnnotationVerifier<DoubleVector3Verifier>("A"s).type().empty());
|
|
CHECK(!AnnotationVerifier<IntVector4Verifier>("A"s).type().empty());
|
|
CHECK(!AnnotationVerifier<DoubleVector4Verifier>("A"s).type().empty());
|
|
|
|
CHECK(!ReferencingVerifier("identifier"s).type().empty());
|
|
}
|
|
|
|
TEST_CASE("Documentation: Verifier Documentation Post Conditions", "[documentation]") {
|
|
using namespace openspace::documentation;
|
|
using namespace std::string_literals;
|
|
|
|
CHECK(!BoolVerifier().documentation().empty());
|
|
CHECK(!DoubleVerifier().documentation().empty());
|
|
CHECK(!IntVerifier().documentation().empty());
|
|
CHECK(!StringVerifier().documentation().empty());
|
|
CHECK(!TableVerifier().documentation().empty());
|
|
|
|
CHECK(!IntVector2Verifier().documentation().empty());
|
|
CHECK(!DoubleVector2Verifier().documentation().empty());
|
|
CHECK(!IntVector3Verifier().documentation().empty());
|
|
CHECK(!DoubleVector3Verifier().documentation().empty());
|
|
CHECK(!IntVector4Verifier().documentation().empty());
|
|
CHECK(!DoubleVector4Verifier().documentation().empty());
|
|
|
|
CHECK(!IntLessVerifier(0).documentation().empty());
|
|
CHECK(!DoubleLessVerifier(0.0).documentation().empty());
|
|
CHECK(!IntLessEqualVerifier(0).documentation().empty());
|
|
CHECK(!DoubleLessEqualVerifier(0.0).documentation().empty());
|
|
CHECK(!IntGreaterVerifier(0).documentation().empty());
|
|
CHECK(!DoubleGreaterVerifier(0.0).documentation().empty());
|
|
CHECK(!IntGreaterEqualVerifier(0).documentation().empty());
|
|
CHECK(!DoubleGreaterEqualVerifier(0.0).documentation().empty());
|
|
|
|
CHECK(!BoolEqualVerifier(true).documentation().empty());
|
|
CHECK(!IntEqualVerifier(0).documentation().empty());
|
|
CHECK(!DoubleEqualVerifier(0.0).documentation().empty());
|
|
CHECK(!StringEqualVerifier(""s).documentation().empty());
|
|
CHECK(!BoolUnequalVerifier(true).documentation().empty());
|
|
CHECK(!IntUnequalVerifier(0).documentation().empty());
|
|
CHECK(!DoubleUnequalVerifier(0.0).documentation().empty());
|
|
CHECK(!StringUnequalVerifier(""s).documentation().empty());
|
|
|
|
CHECK(!BoolInListVerifier({ true }).documentation().empty());
|
|
CHECK(!IntInListVerifier({ 0 }).documentation().empty());
|
|
CHECK(!DoubleInListVerifier({ 0.0 }).documentation().empty());
|
|
CHECK(!StringInListVerifier({ ""s }).documentation().empty());
|
|
CHECK(!BoolNotInListVerifier({ true }).documentation().empty());
|
|
CHECK(!IntNotInListVerifier({ 0 }).documentation().empty());
|
|
CHECK(!DoubleNotInListVerifier({ 0.0 }).documentation().empty());
|
|
CHECK(!StringNotInListVerifier({ ""s }).documentation().empty());
|
|
|
|
CHECK(!IntInRangeVerifier({ 0, 1 }).documentation().empty());
|
|
CHECK(!DoubleInRangeVerifier({ 0.0, 1.0 }).documentation().empty());
|
|
CHECK(!IntNotInRangeVerifier({ 0, 1 }).documentation().empty());
|
|
CHECK(!DoubleNotInRangeVerifier({ 0.0, 1.0 }).documentation().empty());
|
|
|
|
CHECK(!BoolAnnotationVerifier("A"s).documentation().empty());
|
|
CHECK(!IntAnnotationVerifier("A"s).documentation().empty());
|
|
CHECK(!DoubleAnnotationVerifier("A"s).documentation().empty());
|
|
CHECK(!StringAnnotationVerifier("A"s).documentation().empty());
|
|
CHECK(!TableAnnotationVerifier("A"s).documentation().empty());
|
|
CHECK(!AnnotationVerifier<IntVector2Verifier>("A"s).documentation().empty());
|
|
CHECK(!AnnotationVerifier<DoubleVector2Verifier>("A"s).documentation().empty());
|
|
CHECK(!AnnotationVerifier<IntVector3Verifier>("A"s).documentation().empty());
|
|
CHECK(!AnnotationVerifier<DoubleVector3Verifier>("A"s).documentation().empty());
|
|
CHECK(!AnnotationVerifier<IntVector4Verifier>("A"s).documentation().empty());
|
|
CHECK(!AnnotationVerifier<DoubleVector4Verifier>("A"s).documentation().empty());
|
|
|
|
CHECK(!ReferencingVerifier("identifier"s).documentation().empty());
|
|
}
|