mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-02-22 12:59:07 -06:00
Code Issues Packages Projects Releases Wiki Activity

Adding information to the Result that specifies the offending reason in addition to the offending key

Browse Source
This commit is contained in:
Alexander Bock
2016-09-18 15:13:34 +02:00
parent a25a9b4a2d
commit 57701fb5a6
6 changed files with 440 additions and 320 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
include/openspace/documentation/documentation.h
View File

@@ -36,14 +36,22 @@
namespace openspace {
namespace documentation {
struct Verifier;
using Optional = ghoul::Boolean;
using Exhaustive = ghoul::Boolean;
struct TestResult {
struct Offence {
enum class Reason {
MissingKey,
ExtraKey,
WrongType,
Verification
};
std::string offender;
Reason reason;
};
bool success;
std::vector<std::string> offenders;
std::vector<Offence> offenders;
};
struct SpecificationError : public ghoul::RuntimeError {
@@ -52,6 +60,8 @@ struct SpecificationError : public ghoul::RuntimeError {
TestResult result;
};
struct Verifier;
struct DocumentationEntry {
DocumentationEntry(std::string key, Verifier* t, std::string doc = "",
Optional optional = Optional::No);

109
include/openspace/documentation/verifier.h
View File

@@ -27,14 +27,14 @@
#include <openspace/documentation/documentation.h>
#include <functional>
namespace openspace {
namespace documentation {
struct Verifier {
virtual TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const;
virtual bool test(const ghoul::Dictionary& dict, const std::string& key) const;
virtual TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const = 0;
virtual std::string type() const = 0;
virtual std::string documentation() const;
@@ -44,36 +44,36 @@ struct Verifier {
template <typename T>
struct TemplateVerifier : public Verifier {
using Type = T;
TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const override;
};
struct BoolVerifier : public TemplateVerifier<bool> {
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
std::string type() const override;
};
struct DoubleVerifier : public TemplateVerifier<double> {
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
std::string type() const override;
};
struct IntVerifier : public TemplateVerifier<int> {
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const override;
std::string type() const override;
};
struct StringVerifier : public TemplateVerifier<std::string> {
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
std::string type() const override;
};
struct TableVerifier : public TemplateVerifier<ghoul::Dictionary> {
TableVerifier(std::vector<DocumentationEntry> d = {}, Exhaustive exhaustive = Exhaustive::No);
TableVerifier(std::vector<DocumentationEntry> d = {},
Exhaustive exhaustive = Exhaustive::No);
TestResult operator()(const ghoul::Dictionary& dict, const std::string& key) const override;
TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const override;
std::string type() const override;
@@ -85,115 +85,94 @@ struct VectorVerifier {};
template <typename T>
struct Vector2Verifier : public TemplateVerifier<glm::tvec2<T>>, public VectorVerifier {
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
std::string type() const override;
};
template <typename T>
struct Vector3Verifier : public TemplateVerifier<glm::tvec3<T>>, public VectorVerifier {
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
std::string type() const override;
};
template <typename T>
struct Vector4Verifier : public TemplateVerifier<glm::tvec4<T>>, public VectorVerifier {
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
std::string type() const override;
};
// Operator Verifiers
template <typename T, typename Op>
struct OperatorVerifier : public T {
OperatorVerifier(typename T::Type value);
TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const override;
typename T::Type value;
};
template <typename T>
struct LessVerifier : public T {
struct LessVerifier : public OperatorVerifier<T, std::less<typename T::Type>> {
static_assert(!std::is_base_of_v<BoolVerifier, T>, "T cannot be BoolVerifier");
static_assert(!std::is_base_of_v<StringVerifier, T>, "T cannot be StringVerifier");
static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
static_assert(!std::is_base_of_v<VectorVerifier, T>, "T cannot be VectorVerifier");
LessVerifier(typename T::Type value);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
using OperatorVerifier::OperatorVerifier;
std::string documentation() const;
typename T::Type value;
};
template <typename T>
struct LessEqualVerifier : public T {
struct LessEqualVerifier : public OperatorVerifier<T, std::less_equal<typename T::Type>> {
static_assert(!std::is_base_of_v<BoolVerifier, T>, "T cannot be BoolVerifier");
static_assert(!std::is_base_of_v<StringVerifier, T>, "T cannot be StringVerifier");
static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
static_assert(!std::is_base_of_v<VectorVerifier, T>, "T cannot be VectorVerifier");
LessEqualVerifier(typename T::Type value);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
using OperatorVerifier::OperatorVerifier;
std::string documentation() const override;
typename T::Type value;
};
template <typename T>
struct GreaterVerifier : public T {
struct GreaterVerifier : public OperatorVerifier<T, std::greater<typename T::Type>> {
static_assert(!std::is_base_of_v<BoolVerifier, T>, "T cannot be BoolVerifier");
static_assert(!std::is_base_of_v<StringVerifier, T>, "T cannot be StringVerifier");
static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
static_assert(!std::is_base_of_v<VectorVerifier, T>, "T cannot be VectorVerifier");
GreaterVerifier(typename T::Type value);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
using OperatorVerifier::OperatorVerifier;
std::string documentation() const override;
typename T::Type value;
};
template <typename T>
struct GreaterEqualVerifier : public T {
struct GreaterEqualVerifier : public OperatorVerifier<T, std::greater_equal<typename T::Type>> {
static_assert(!std::is_base_of_v<BoolVerifier, T>, "T cannot be BoolVerifier");
static_assert(!std::is_base_of_v<StringVerifier, T>, "T cannot be StringVerifier");
static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
static_assert(!std::is_base_of_v<VectorVerifier, T>, "T cannot be VectorVerifier");
GreaterEqualVerifier(typename T::Type value);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
using OperatorVerifier::OperatorVerifier;
std::string documentation() const override;
typename T::Type value;
};
template <typename T>
struct EqualVerifier : public T {
struct EqualVerifier : public OperatorVerifier<T, std::equal_to<typename T::Type>> {
static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
EqualVerifier(typename T::Type value);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
using OperatorVerifier::OperatorVerifier;
std::string documentation() const override;
typename T::Type value;
};
template <typename T>
struct UnequalVerifier : public T {
struct UnequalVerifier : public OperatorVerifier<T, std::not_equal_to<typename T::Type>> {
static_assert(!std::is_base_of_v<TableVerifier, T>, "T cannot be TableVerifier");
UnequalVerifier(typename T::Type value);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
using OperatorVerifier::OperatorVerifier;
std::string documentation() const override;
typename T::Type value;
};
// List Verifiers
@@ -204,7 +183,8 @@ struct InListVerifier : public T {
InListVerifier(std::vector<typename T::Type> values);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const override;
std::string documentation() const override;
@@ -217,7 +197,8 @@ struct NotInListVerifier : public T {
NotInListVerifier(std::vector<typename T::Type> values);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const override;
std::string documentation() const override;
@@ -234,7 +215,8 @@ struct InRangeVerifier : public T {
InRangeVerifier(typename T::Type lower, typename T::Type upper);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const override;
std::string documentation() const override;
@@ -251,7 +233,8 @@ struct NotInRangeVerifier : public T {
NotInRangeVerifier(typename T::Type lower, typename T::Type upper);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const override;
std::string documentation() const override;
@@ -265,8 +248,6 @@ template <typename T>
struct AnnotationVerifier : public T {
AnnotationVerifier(std::string annotation);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
std::string documentation() const override;
std::string annotation;
@@ -277,7 +258,8 @@ struct AnnotationVerifier : public T {
struct AndVerifier : public Verifier {
AndVerifier(Verifier* a, Verifier* b);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const override;
std::string type() const override;
std::string documentation() const override;
@@ -289,7 +271,8 @@ struct AndVerifier : public Verifier {
struct OrVerifier : public Verifier {
OrVerifier(Verifier* a, Verifier* b);
bool test(const ghoul::Dictionary& dict, const std::string& key) const override;
TestResult operator()(const ghoul::Dictionary& dict,
const std::string& key) const override;
std::string type() const override;
std::string documentation() const override;

181
include/openspace/documentation/verifier.inl
View File

@@ -32,8 +32,20 @@ namespace openspace {
namespace documentation {
template <typename T>
bool Vector2Verifier<T>::test(const ghoul::Dictionary& d, const std::string& k) const {
return d.hasKeyAndValue<glm::tvec2<T>>(k);
TestResult TemplateVerifier<T>::operator()(const ghoul::Dictionary& dict,
const std::string& key) const
{
if (dict.hasKey(key)) {
if (dict.hasValue<Type>(key)) {
return{ true, {} };
}
else {
return { false, { { key, TestResult::Offence::Reason::WrongType } } };
}
}
else {
return { false, { { key, TestResult::Offence::Reason::MissingKey } } };
}
}
template <typename T>
@@ -43,11 +55,6 @@ std::string Vector2Verifier<T>::type() const {
return "Vector2<"s + typeid(T).name() + ">";
}
template <typename T>
bool Vector3Verifier<T>::test(const ghoul::Dictionary& d, const std::string& k) const {
return d.hasKeyAndValue<glm::tvec3<T>>(k);
}
template <typename T>
std::string Vector3Verifier<T>::type() const {
using namespace std::string_literals;
@@ -55,11 +62,6 @@ std::string Vector3Verifier<T>::type() const {
return "Vector3<"s + typeid(T).name() + ">";
}
template <typename T>
bool Vector4Verifier<T>::test(const ghoul::Dictionary& d, const std::string& k) const {
return d.hasKeyAndValue<glm::tvec4<T>>(k);
}
template <typename T>
std::string Vector4Verifier<T>::type() const {
using namespace std::string_literals;
@@ -67,15 +69,27 @@ std::string Vector4Verifier<T>::type() const {
return "Vector4<"s + typeid(T).name() + ">";
}
template <typename T>
LessVerifier<T>::LessVerifier(typename T::Type value)
template <typename T, typename Op>
OperatorVerifier<T, Op>::OperatorVerifier(typename T::Type value)
: value(std::move(value))
{
}
{}
template <typename T>
bool LessVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
return T::test(dict, key) && dict.value<Type>(key) < value;
template <typename T, typename Op>
TestResult OperatorVerifier<T, Op>::operator()(const ghoul::Dictionary& dict,
const std::string& key) const
{
TestResult res = T::operator()(dict, key);
if (res.success) {
if (Op()(dict.value<Type>(key), value)) {
return { true, {} };
}
else {
return { false, { { key, TestResult::Offence::Reason::Verification }}};
}
}
else {
return res;
}
}
template <typename T>
@@ -83,77 +97,26 @@ std::string LessVerifier<T>::documentation() const {
return "Less than: " + std::to_string(value);
}
template <typename T>
LessEqualVerifier<T>::LessEqualVerifier(typename T::Type value)
: value(std::move(value))
{}
template <typename T>
bool LessEqualVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
return T::test(dict, key) && dict.value<Type>(key) <= value;
}
template <typename T>
std::string LessEqualVerifier<T>::documentation() const {
return "Less or equal to: " + std::to_string(value);
}
template <typename T>
GreaterVerifier<T>::GreaterVerifier(typename T::Type value)
: value(std::move(value))
{}
template <typename T>
bool GreaterVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
return T::test(dict, key) && dict.value<Type>(key) > value;
}
template <typename T>
std::string GreaterVerifier<T>::documentation() const {
return "Greater than: " + std::to_string(value);
}
template <typename T>
GreaterEqualVerifier<T>::GreaterEqualVerifier(typename T::Type value)
: value(std::move(value))
{}
template <typename T>
bool GreaterEqualVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
return T::test(dict, key) && dict.value<Type>(key) >= value;
}
template <typename T>
std::string GreaterEqualVerifier<T>::documentation() const {
return "Greater or equal to: " + std::to_string(value);
}
template <typename T>
EqualVerifier<T>::EqualVerifier(typename T::Type value)
: value(std::move(value))
{}
template <typename T>
bool EqualVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
return T::test(dict, key) && dict.value<Type>(key) == value;
}
template <typename T>
std::string EqualVerifier<T>::documentation() const {
return "Equal to: " + std::to_string(value);
}
template <typename T>
UnequalVerifier<T>::UnequalVerifier(typename T::Type value)
: value(std::move(value))
{}
template <typename T>
bool UnequalVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
return T::test(dict, key) && dict.value<Type>(key) != value;
}
template <typename T>
std::string UnequalVerifier<T>::documentation() const {
return "Unequal to: " + std::to_string(value);
@@ -165,15 +128,24 @@ InListVerifier<T>::InListVerifier(std::vector<typename T::Type> values)
{}
template <typename T>
bool InListVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
if (T::test(dict, key)) {
TestResult InListVerifier<T>::operator()(const ghoul::Dictionary& dict,
const std::string& key) const
{
TestResult res = T::operator()(dict, key);
if (res.success) {
typename T::Type value = dict.value<typename T::Type>(key);
auto it = std::find(values.begin(), values.end(), value);
return it != values.end();
if (it != values.end()) {
return { true, {} };
}
else {
return { false, { { key, TestResult::Offence::Reason::Verification } } };
}
}
else {
return false;
return res;
}
}
@@ -198,15 +170,24 @@ NotInListVerifier<T>::NotInListVerifier(std::vector<typename T::Type> values)
{}
template <typename T>
bool NotInListVerifier<T>::test(const ghoul::Dictionary& dict, const std::string& key) const {
if (T::test(dict, key)) {
TestResult NotInListVerifier<T>::operator()(const ghoul::Dictionary& dict,
const std::string& key) const
{
TestResult res = T::operator()(dict, key);
if (res.success) {
typename T::Type value = dict.value<typename T::Type>(key);
auto it = std::find(values.begin(), values.end(), value);
return it == values.end();
if (it == values.end()) {
return { true, {} };
}
else {
return { false, { { key, TestResult::Offence::Reason::Verification } } };
}
}
else {
return false;
return res;
}
}
@@ -234,14 +215,24 @@ InRangeVerifier<T>::InRangeVerifier(typename T::Type lower, typename T::Type upp
ghoul_assert(lower <= upper, "Lower value must be smaller or equal to upper value");
}
template <typename T>
bool InRangeVerifier<T>::test(const ghoul::Dictionary& d, const std::string& key) const {
if (T::test(d, key)) {
typename T::Type val = d.value<typename T::Type>(key);
return val >= lower && val <= upper;
TestResult InRangeVerifier<T>::operator()(const ghoul::Dictionary& dict,
const std::string& key) const
{
TestResult res = T::operator()(dict, key);
if (res.success) {
typename T::Type val = dict.value<typename T::Type>(key);
if (val >= lower && val <= upper) {
return { true, {} };
}
else {
return { false, { { key, TestResult::Offence::Reason::Verification } } };
}
}
else {
return false;
return res;
}
}
@@ -260,13 +251,21 @@ NotInRangeVerifier<T>::NotInRangeVerifier(typename T::Type lower, typename T::Ty
}
template <typename T>
bool NotInRangeVerifier<T>::test(const ghoul::Dictionary& d, const std::string& k) const {
if (T::test(d, k)) {
typename T::Type val = d.value<typename T::Type>(k);
return !(val >= lower && val <= upper);
TestResult NotInRangeVerifier<T>::operator()(const ghoul::Dictionary& dict,
const std::string& key) const {
TestResult res = T::operator()(dict, key);
if (res.success) {
typename T::Type val = dict.value<typename T::Type>(key);
if (val >= lower && val <= upper) {
return { false, { { key, TestResult::Offence::Reason::Verification } } };
}
else {
return { true, {} };
}
}
else {
return false;
return res;
}
}
@@ -282,12 +281,6 @@ AnnotationVerifier<T>::AnnotationVerifier(std::string annotation)
: annotation(std::move(annotation))
{}
template <typename T>
bool AnnotationVerifier<T>::test(const ghoul::Dictionary& dict,
const std::string& key) const
{
return T::test(dict, key);
}
template <typename T>
std::string AnnotationVerifier<T>::documentation() const {

24
src/documentation/documentation.cpp
View File

@@ -29,6 +29,22 @@
namespace {
const std::string Wildcard = "*";
// Structure used to make offences unique
struct OffenceCompare {
using Offence = openspace::documentation::TestResult::Offence;
bool operator()(const Offence& lhs, const Offence& rhs) const
{
if (lhs.offender != rhs.offender) {
return lhs.offender < rhs.offender;
}
else {
return std::underlying_type_t<Offence::Reason>(lhs.reason) <
std::underlying_type_t<Offence::Reason>(rhs.reason);
}
}
};
} // namespace
namespace std {
@@ -119,17 +135,19 @@ TestResult testSpecification(const Documentation& d, const ghoul::Dictionary& di
if (it == d.entries.end()) {
result.success = false;
result.offenders.push_back(key);
result.offenders.push_back(
{ key, TestResult::Offence::Reason::ExtraKey }
);
}
}
}
// Remove duplicate offenders that might occur if multiple rules apply to a single
// key and more than one of these rules are broken
std::set<std::string> uniqueOffenders(
std::set<TestResult::Offence, OffenceCompare> uniqueOffenders(
result.offenders.begin(), result.offenders.end()
);
result.offenders = std::vector<std::string>(
result.offenders = std::vector<TestResult::Offence>(
uniqueOffenders.begin(), uniqueOffenders.end()
);

102
src/documentation/verifier.cpp
View File

@@ -74,56 +74,45 @@ template struct AnnotationVerifier<DoubleVerifier>;
template struct AnnotationVerifier<StringVerifier>;
template struct AnnotationVerifier<TableVerifier>;
TestResult Verifier::operator()(const ghoul::Dictionary& dict,
const std::string& key) const
{
bool testSuccess = test(dict, key);
if (testSuccess) {
return { testSuccess,{} };
}
else {
return { testSuccess,{ key } };
}
}
bool Verifier::test(const ghoul::Dictionary& dict, const std::string& key) const {
return false;
};
std::string Verifier::documentation() const {
return "";
}
bool BoolVerifier::test(const ghoul::Dictionary& dict, const std::string& key) const {
return dict.hasKeyAndValue<Type>(key);
}
std::string BoolVerifier::type() const {
return "Boolean";
}
bool DoubleVerifier::test(const ghoul::Dictionary & dict, const std::string & key) const {
return dict.hasKeyAndValue<Type>(key);
}
std::string DoubleVerifier::type() const {
return "Double";
}
bool IntVerifier::test(const ghoul::Dictionary & dict, const std::string & key) const {
TestResult IntVerifier::operator()(const ghoul::Dictionary & dict,
const std::string & key) const
{
if (dict.hasKeyAndValue<int>(key)) {
return true;
return { true, {} };
}
else {
if (dict.hasKeyAndValue<double>(key)) {
// If we have a double value, we need to check if it is integer
double value = dict.value<double>(key);
double intPart;
return modf(value, &intPart) == 0.0;
if (dict.hasKey(key)) {
if (dict.hasValue<double>(key)) {
// If we have a double value, we need to check if it is integer
double value = dict.value<double>(key);
double intPart;
bool isInt = modf(value, &intPart) == 0.0;
if (isInt) {
return { true,{} };
}
else {
return { false, { { key, TestResult::Offence::Reason::WrongType } } };
}
}
else {
// If we don't have a double value, we cannot have an int value
return { false, { { key, TestResult::Offence::Reason::WrongType } } };
}
}
else {
// If we don't have a double value, we cannot have an int value
return false;
return { false, { {key, TestResult::Offence::Reason::MissingKey }}};
}
}
}
@@ -132,10 +121,6 @@ std::string IntVerifier::type() const {
return "Integer";
}
bool StringVerifier::test(const ghoul::Dictionary & dict, const std::string & key) const {
return dict.hasKeyAndValue<Type>(key);
}
std::string StringVerifier::type() const {
return "String";
}
@@ -149,16 +134,24 @@ TestResult TableVerifier::operator()(const ghoul::Dictionary& dict,
const std::string& key) const
{
if (dict.hasKeyAndValue<Type>(key)) {
ghoul::Dictionary d = dict.value<Type>(key);
ghoul::Dictionary d = dict.value<ghoul::Dictionary>(key);
TestResult res = testSpecification({ "", doc, exhaustive }, d);
for (std::string& s : res.offenders) {
s = key + "." + s;
for (TestResult::Offence& s : res.offenders) {
s.offender = key + "." + s.offender;
}
return res;
}
return { dict.hasKeyAndValue<Type>(key), { key } };
else {
if (dict.hasKey(key)) {
return { false, { { key, TestResult::Offence::Reason::WrongType } } };
}
else {
return { false, { { key, TestResult::Offence::Reason::MissingKey } } };
}
}
}
std::string TableVerifier::type() const {
@@ -172,8 +165,18 @@ AndVerifier::AndVerifier(Verifier* a, Verifier* b)
ghoul_assert(a->type() == b->type(), "Cannot use AndVerifier with different types");
}
bool AndVerifier::test(const ghoul::Dictionary& dict, const std::string& key) const {
return a->test(dict, key) && b->test(dict, key);
TestResult AndVerifier::operator()(const ghoul::Dictionary& dict,
const std::string& key) const
{
TestResult resA = a->operator()(dict, key);
TestResult resB = b->operator()(dict, key);
if (resA.success && resB.success) {
return { true, {} };
}
else {
return { false, { { key, TestResult::Offence::Reason::Verification } } };
}
}
std::string AndVerifier::type() const {
@@ -190,8 +193,17 @@ OrVerifier::OrVerifier(Verifier* a, Verifier* b)
, b(b)
{}
bool OrVerifier::test(const ghoul::Dictionary& dict, const std::string& key) const {
return a->test(dict, key) || b->test(dict, key);
TestResult OrVerifier::operator()(const ghoul::Dictionary& dict,
const std::string& key) const {
TestResult resA = a->operator()(dict, key);
TestResult resB = b->operator()(dict, key);
if (resA.success || resB.success) {
return { true, {} };
}
else {
return { false, { { key, TestResult::Offence::Reason::Verification } } };
}
}
std::string OrVerifier::type() const {

328
tests/test_documentation.inl
View File

@@ -180,7 +180,8 @@ TEST_F(DocumentationTest, BoolVerifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Bool", negativeRes.offenders[0]);
EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negativeExist {
{ "Bool2", 0}
@@ -189,7 +190,8 @@ TEST_F(DocumentationTest, BoolVerifier) {
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Bool", negativeRes.offenders[0]);
EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, DoubleVerifier) {
@@ -215,15 +217,17 @@ TEST_F(DocumentationTest, DoubleVerifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negativeExist{
{ "Double2" , 0.0 }
};
negativeRes = testSpecification(doc, negative);
negativeRes = testSpecification(doc, negativeExist);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, IntVerifier) {
@@ -255,15 +259,17 @@ TEST_F(DocumentationTest, IntVerifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negativeExist {
{ "Int2", 0 }
};
negativeRes = testSpecification(doc, negative);
negativeRes = testSpecification(doc, negativeExist);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, StringVerifier) {
@@ -288,15 +294,17 @@ TEST_F(DocumentationTest, StringVerifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("String", negativeRes.offenders[0]);
EXPECT_EQ("String", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negativeExist {
{ "String2", ""s }
};
negativeRes = testSpecification(doc, negative);
negativeRes = testSpecification(doc, negativeExist);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("String", negativeRes.offenders[0]);
EXPECT_EQ("String", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, TableVerifierType) {
@@ -320,15 +328,17 @@ TEST_F(DocumentationTest, TableVerifierType) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Table", negativeRes.offenders[0]);
EXPECT_EQ("Table", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negativeExist {
{ "Table2", ghoul::Dictionary{} }
};
negativeRes = testSpecification(doc, negative);
negativeRes = testSpecification(doc, negativeExist);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Table", negativeRes.offenders[0]);
EXPECT_EQ("Table", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, MixedVerifiers) {
@@ -367,7 +377,8 @@ TEST_F(DocumentationTest, MixedVerifiers) {
TestResult negativeRes = testSpecification(doc, negative1);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "Bool", true },
@@ -379,8 +390,10 @@ TEST_F(DocumentationTest, MixedVerifiers) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(2, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("String", negativeRes.offenders[1]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
EXPECT_EQ("String", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
}
TEST_F(DocumentationTest, NestedTables) {
@@ -440,7 +453,8 @@ TEST_F(DocumentationTest, NestedTables) {
TestResult negativeRes = testSpecification(doc, negativeSimple);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Outer_Table", negativeRes.offenders[0]);
EXPECT_EQ("Outer_Table", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negativeInner {
{ "Outer_Int", 1 },
@@ -460,7 +474,8 @@ TEST_F(DocumentationTest, NestedTables) {
negativeRes = testSpecification(doc, negativeInner);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0]);
EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negativeInner2 {
{ "Outer_Int", 1 },
@@ -480,8 +495,10 @@ TEST_F(DocumentationTest, NestedTables) {
negativeRes = testSpecification(doc, negativeInner2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(2, negativeRes.offenders.size());
EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0]);
EXPECT_EQ("Outer_Table.Inner_String", negativeRes.offenders[1]);
EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
EXPECT_EQ("Outer_Table.Inner_String", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
ghoul::Dictionary negativeInnerSeparate {
{ "Outer_Int", 1 },
@@ -501,8 +518,10 @@ TEST_F(DocumentationTest, NestedTables) {
negativeRes = testSpecification(doc, negativeInnerSeparate);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(2, negativeRes.offenders.size());
EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0]);
EXPECT_EQ("Outer_Table2.Inner_Double2", negativeRes.offenders[1]);
EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
EXPECT_EQ("Outer_Table2.Inner_Double2", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
ghoul::Dictionary negativeInnerFull {
{ "Outer_Int", 1 },
@@ -522,9 +541,12 @@ TEST_F(DocumentationTest, NestedTables) {
negativeRes = testSpecification(doc, negativeInnerFull);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(3, negativeRes.offenders.size());
EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0]);
EXPECT_EQ("Outer_Table2.Inner_Double2", negativeRes.offenders[1]);
EXPECT_EQ("Outer_Table2.Inner_Table.Inner_Inner_Int", negativeRes.offenders[2]);
EXPECT_EQ("Outer_Table.Inner_Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
EXPECT_EQ("Outer_Table2.Inner_Double2", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
EXPECT_EQ("Outer_Table2.Inner_Table.Inner_Inner_Int", negativeRes.offenders[2].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[2].reason);
}
TEST_F(DocumentationTest, Optional) {
@@ -558,7 +580,8 @@ TEST_F(DocumentationTest, Optional) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Bool_Force", negativeRes.offenders[0]);
EXPECT_EQ("Bool_Force", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "Bool_Optional", true }
@@ -566,7 +589,8 @@ TEST_F(DocumentationTest, Optional) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Bool_Force", negativeRes.offenders[0]);
EXPECT_EQ("Bool_Force", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
ghoul::Dictionary negative3 {
{ "Bool_Force", true },
@@ -575,7 +599,8 @@ TEST_F(DocumentationTest, Optional) {
negativeRes = testSpecification(doc, negative3);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Bool_Optional", negativeRes.offenders[0]);
EXPECT_EQ("Bool_Optional", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, RequiredInOptional) {
@@ -636,7 +661,8 @@ TEST_F(DocumentationTest, RequiredInOptional) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a.b", negativeRes.offenders[0]);
EXPECT_EQ("a.b", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, Exhaustive) {
@@ -661,8 +687,10 @@ TEST_F(DocumentationTest, Exhaustive) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(2, negativeRes.offenders.size());
EXPECT_EQ("False_Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[1]);
EXPECT_EQ("False_Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::ExtraKey, negativeRes.offenders[0].reason);
EXPECT_EQ("Int", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[1].reason);
ghoul::Dictionary negative2 {
{ "Double", 2.0 }
@@ -670,8 +698,10 @@ TEST_F(DocumentationTest, Exhaustive) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(2, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[1]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::ExtraKey, negativeRes.offenders[0].reason);
EXPECT_EQ("Int", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[1].reason);
}
TEST_F(DocumentationTest, NestedExhaustive) {
@@ -699,8 +729,10 @@ TEST_F(DocumentationTest, NestedExhaustive) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(2, negativeRes.offenders.size());
EXPECT_EQ("Table.a", negativeRes.offenders[0]);
EXPECT_EQ("Table.b", negativeRes.offenders[1]);
EXPECT_EQ("Table.a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::MissingKey, negativeRes.offenders[0].reason);
EXPECT_EQ("Table.b", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::ExtraKey, negativeRes.offenders[1].reason);
}
TEST_F(DocumentationTest, LessInt) {
@@ -724,7 +756,8 @@ TEST_F(DocumentationTest, LessInt) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, LessDouble) {
@@ -748,7 +781,8 @@ TEST_F(DocumentationTest, LessDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, LessEqualInt) {
@@ -779,7 +813,8 @@ TEST_F(DocumentationTest, LessEqualInt) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, LessEqualDouble) {
@@ -810,7 +845,8 @@ TEST_F(DocumentationTest, LessEqualDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, GreaterInt) {
@@ -829,12 +865,13 @@ TEST_F(DocumentationTest, GreaterInt) {
EXPECT_EQ(0, positiveRes.offenders.size());
ghoul::Dictionary negative {
{ "Int", 00 }
{ "Int", 0 }
};
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, GreaterDouble) {
@@ -858,7 +895,8 @@ TEST_F(DocumentationTest, GreaterDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, GreaterEqualInt) {
@@ -889,7 +927,8 @@ TEST_F(DocumentationTest, GreaterEqualInt) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, GreaterEqualDouble) {
@@ -920,10 +959,10 @@ TEST_F(DocumentationTest, GreaterEqualDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, EqualBool) {
using namespace openspace::documentation;
@@ -945,7 +984,8 @@ TEST_F(DocumentationTest, EqualBool) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Bool", negativeRes.offenders[0]);
EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, EqualInt) {
@@ -969,7 +1009,8 @@ TEST_F(DocumentationTest, EqualInt) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, EqualDouble) {
@@ -993,7 +1034,8 @@ TEST_F(DocumentationTest, EqualDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, EqualString) {
@@ -1018,7 +1060,8 @@ TEST_F(DocumentationTest, EqualString) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("String", negativeRes.offenders[0]);
EXPECT_EQ("String", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, UnequalBool) {
@@ -1042,7 +1085,8 @@ TEST_F(DocumentationTest, UnequalBool) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Bool", negativeRes.offenders[0]);
EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, UnequalInt) {
@@ -1066,7 +1110,8 @@ TEST_F(DocumentationTest, UnequalInt) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, UnequalDouble) {
@@ -1090,7 +1135,8 @@ TEST_F(DocumentationTest, UnequalDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, UnequalString) {
@@ -1115,7 +1161,8 @@ TEST_F(DocumentationTest, UnequalString) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("String", negativeRes.offenders[0]);
EXPECT_EQ("String", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, ListBool) {
@@ -1139,7 +1186,8 @@ TEST_F(DocumentationTest, ListBool) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Bool", negativeRes.offenders[0]);
EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, ListInt) {
@@ -1170,7 +1218,8 @@ TEST_F(DocumentationTest, ListInt) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, ListDouble) {
@@ -1201,7 +1250,8 @@ TEST_F(DocumentationTest, ListDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, ListString) {
@@ -1233,7 +1283,8 @@ TEST_F(DocumentationTest, ListString) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("String", negativeRes.offenders[0]);
EXPECT_EQ("String", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, NotListBool) {
@@ -1257,7 +1308,8 @@ TEST_F(DocumentationTest, NotListBool) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Bool", negativeRes.offenders[0]);
EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, NotListInt) {
@@ -1288,7 +1340,8 @@ TEST_F(DocumentationTest, NotListInt) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, NotListDouble) {
@@ -1319,7 +1372,8 @@ TEST_F(DocumentationTest, NotListDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, NotListString) {
@@ -1351,7 +1405,8 @@ TEST_F(DocumentationTest, NotListString) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("String", negativeRes.offenders[0]);
EXPECT_EQ("String", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, AnnotationBool) {
@@ -1375,7 +1430,8 @@ TEST_F(DocumentationTest, AnnotationBool) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Bool", negativeRes.offenders[0]);
EXPECT_EQ("Bool", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, AnnotationInt) {
@@ -1399,7 +1455,8 @@ TEST_F(DocumentationTest, AnnotationInt) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, AnnotationDouble) {
@@ -1423,7 +1480,8 @@ TEST_F(DocumentationTest, AnnotationDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, AnnotationString) {
@@ -1448,7 +1506,8 @@ TEST_F(DocumentationTest, AnnotationString) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("String", negativeRes.offenders[0]);
EXPECT_EQ("String", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, AnnotationTable) {
@@ -1472,7 +1531,8 @@ TEST_F(DocumentationTest, AnnotationTable) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Table", negativeRes.offenders[0]);
EXPECT_EQ("Table", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, InRangeInt) {
@@ -1510,7 +1570,8 @@ TEST_F(DocumentationTest, InRangeInt) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, InRangeDouble) {
@@ -1555,7 +1616,8 @@ TEST_F(DocumentationTest, InRangeDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, NotInRangeInt) {
@@ -1586,7 +1648,8 @@ TEST_F(DocumentationTest, NotInRangeInt) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "Int", 0 }
@@ -1594,7 +1657,8 @@ TEST_F(DocumentationTest, NotInRangeInt) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
ghoul::Dictionary negative3 {
{ "Int", 5 }
@@ -1602,7 +1666,8 @@ TEST_F(DocumentationTest, NotInRangeInt) {
negativeRes = testSpecification(doc, negative3);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Int", negativeRes.offenders[0]);
EXPECT_EQ("Int", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, NotInRangeDouble) {
@@ -1633,7 +1698,8 @@ TEST_F(DocumentationTest, NotInRangeDouble) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "Double", 5.0 }
@@ -1641,7 +1707,8 @@ TEST_F(DocumentationTest, NotInRangeDouble) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
ghoul::Dictionary negative3 {
{ "Double", 2.5 }
@@ -1649,7 +1716,8 @@ TEST_F(DocumentationTest, NotInRangeDouble) {
negativeRes = testSpecification(doc, negative3);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("Double", negativeRes.offenders[0]);
EXPECT_EQ("Double", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, Wildcard) {
@@ -1677,7 +1745,8 @@ TEST_F(DocumentationTest, Wildcard) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "a", false },
@@ -1687,8 +1756,10 @@ TEST_F(DocumentationTest, Wildcard) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(2, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("b", negativeRes.offenders[1]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
EXPECT_EQ("b", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
ghoul::Dictionary negative3 {
{ "a", false },
@@ -1698,9 +1769,12 @@ TEST_F(DocumentationTest, Wildcard) {
negativeRes = testSpecification(doc, negative3);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(3, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("b", negativeRes.offenders[1]);
EXPECT_EQ("c", negativeRes.offenders[2]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
EXPECT_EQ("b", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
EXPECT_EQ("c", negativeRes.offenders[2].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[2].reason);
}
TEST_F(DocumentationTest, WildcardMixed) {
@@ -1731,8 +1805,10 @@ TEST_F(DocumentationTest, WildcardMixed) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(2, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("b", negativeRes.offenders[1]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
EXPECT_EQ("b", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[1].reason);
ghoul::Dictionary negative2 {
{ "a", false },
@@ -1742,8 +1818,10 @@ TEST_F(DocumentationTest, WildcardMixed) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(2, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("b", negativeRes.offenders[1]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
EXPECT_EQ("b", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
ghoul::Dictionary negative3 {
{ "a", false },
@@ -1753,9 +1831,12 @@ TEST_F(DocumentationTest, WildcardMixed) {
negativeRes = testSpecification(doc, negative3);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(3, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("b", negativeRes.offenders[1]);
EXPECT_EQ("c", negativeRes.offenders[2]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
EXPECT_EQ("b", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[1].reason);
EXPECT_EQ("c", negativeRes.offenders[2].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[2].reason);
ghoul::Dictionary negative4 {
{ "a", false },
@@ -1765,8 +1846,10 @@ TEST_F(DocumentationTest, WildcardMixed) {
negativeRes = testSpecification(doc, negative4);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(2, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("c", negativeRes.offenders[1]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
EXPECT_EQ("c", negativeRes.offenders[1].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[1].reason);
}
TEST_F(DocumentationTest, AndOperator) {
@@ -1795,7 +1878,8 @@ TEST_F(DocumentationTest, AndOperator) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "a", 8 }
@@ -1803,7 +1887,8 @@ TEST_F(DocumentationTest, AndOperator) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, OrOperator) {
@@ -1835,7 +1920,8 @@ TEST_F(DocumentationTest, OrOperator) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::Verification, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, BoolVector2Verifier) {
@@ -1854,12 +1940,13 @@ TEST_F(DocumentationTest, BoolVector2Verifier) {
EXPECT_EQ(0, positiveRes.offenders.size());
ghoul::Dictionary negative {
{ "a", ghoul::Dictionary{ {"1", true}, {"2", 1.0} } }
{ "a", ghoul::Dictionary{ { "1", true }, { "2", 1.0 } } }
};
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "a", true }
@@ -1867,7 +1954,8 @@ TEST_F(DocumentationTest, BoolVector2Verifier) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, IntVector2Verifier) {
@@ -1891,7 +1979,8 @@ TEST_F(DocumentationTest, IntVector2Verifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "a", true }
@@ -1899,7 +1988,8 @@ TEST_F(DocumentationTest, IntVector2Verifier) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, DoubleVector2Verifier) {
@@ -1923,7 +2013,8 @@ TEST_F(DocumentationTest, DoubleVector2Verifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "a", true }
@@ -1931,7 +2022,8 @@ TEST_F(DocumentationTest, DoubleVector2Verifier) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, BoolVector3Verifier) {
@@ -1955,7 +2047,8 @@ TEST_F(DocumentationTest, BoolVector3Verifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "a", true }
@@ -1963,7 +2056,8 @@ TEST_F(DocumentationTest, BoolVector3Verifier) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, IntVector3Verifier) {
@@ -1987,7 +2081,8 @@ TEST_F(DocumentationTest, IntVector3Verifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "a", true }
@@ -1995,7 +2090,8 @@ TEST_F(DocumentationTest, IntVector3Verifier) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, DoubleVector3Verifier) {
@@ -2019,7 +2115,8 @@ TEST_F(DocumentationTest, DoubleVector3Verifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "a", true }
@@ -2027,7 +2124,8 @@ TEST_F(DocumentationTest, DoubleVector3Verifier) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, BoolVector4Verifier) {
@@ -2051,7 +2149,8 @@ TEST_F(DocumentationTest, BoolVector4Verifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "a", true }
@@ -2059,7 +2158,8 @@ TEST_F(DocumentationTest, BoolVector4Verifier) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, IntVector4Verifier) {
@@ -2083,7 +2183,8 @@ TEST_F(DocumentationTest, IntVector4Verifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2{
{ "a", true }
@@ -2091,7 +2192,8 @@ TEST_F(DocumentationTest, IntVector4Verifier) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}
TEST_F(DocumentationTest, DoubleVector4Verifier) {
@@ -2115,7 +2217,8 @@ TEST_F(DocumentationTest, DoubleVector4Verifier) {
TestResult negativeRes = testSpecification(doc, negative);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
ghoul::Dictionary negative2 {
{ "a", true }
@@ -2123,5 +2226,6 @@ TEST_F(DocumentationTest, DoubleVector4Verifier) {
negativeRes = testSpecification(doc, negative2);
EXPECT_FALSE(negativeRes.success);
ASSERT_EQ(1, negativeRes.offenders.size());
EXPECT_EQ("a", negativeRes.offenders[0]);
EXPECT_EQ("a", negativeRes.offenders[0].offender);
EXPECT_EQ(TestResult::Offence::Reason::WrongType, negativeRes.offenders[0].reason);
}