diff options
Diffstat (limited to 'test/core/common/ArgumentTest.cpp')
| -rw-r--r-- | test/core/common/ArgumentTest.cpp | 441 |
1 files changed, 427 insertions, 14 deletions
diff --git a/test/core/common/ArgumentTest.cpp b/test/core/common/ArgumentTest.cpp index 8976fba..d555cd8 100644 --- a/test/core/common/ArgumentTest.cpp +++ b/test/core/common/ArgumentTest.cpp @@ -20,8 +20,10 @@ #include <gtest/gtest.h> -#include <core/common/Logger.hpp> #include <core/common/Argument.hpp> +#include <core/common/Function.hpp> +#include <core/common/Logger.hpp> +#include <core/common/Rtti.hpp> #include <core/managed/Managed.hpp> @@ -30,10 +32,32 @@ namespace ousia { //static Logger logger; static TerminalLogger logger(std::cerr, true); +namespace { + +class TestManaged1 : public Managed { +public: + using Managed::Managed; +}; + +class TestManaged2 : public TestManaged1 { +public: + using TestManaged1::TestManaged1; +}; +} + +namespace RttiTypes { +static const Rtti<ousia::TestManaged1> TestManaged1 = + RttiBuilder("TestManaged1"); +static const Rtti<ousia::TestManaged2> TestManaged2 = + RttiBuilder("TestManaged2").parent(&TestManaged1); +} + TEST(Argument, validateBool) { Argument a = Argument::Bool("a"); + ASSERT_FALSE(a.hasDefault); + { Variant v{true}; ASSERT_TRUE(a.validate(v, logger)); @@ -60,16 +84,37 @@ TEST(Argument, validateBoolDefault) { Argument a = Argument::Bool("a", true); - Variant v{1}; - ASSERT_FALSE(a.validate(v, logger)); - ASSERT_TRUE(v.isBool()); - ASSERT_TRUE(v.asBool()); + ASSERT_TRUE(a.hasDefault); + ASSERT_TRUE(a.defaultValue.asBool()); + + { + Variant v{true}; + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isBool()); + ASSERT_TRUE(v.asBool()); + } + + { + Variant v{false}; + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isBool()); + ASSERT_FALSE(v.asBool()); + } + + { + Variant v{1}; + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isBool()); + ASSERT_TRUE(v.asBool()); + } } TEST(Argument, validateInt) { Argument a = Argument::Int("a"); + ASSERT_FALSE(a.hasDefault); + { Variant v{123}; ASSERT_TRUE(a.validate(v, logger)); @@ -89,16 +134,30 @@ TEST(Argument, validateIntDefault) { Argument a = Argument::Int("a", 42); - Variant v{1.1}; - ASSERT_FALSE(a.validate(v, logger)); - ASSERT_TRUE(v.isInt()); - ASSERT_EQ(42, v.asInt()); + ASSERT_TRUE(a.hasDefault); + ASSERT_EQ(42, a.defaultValue.asInt()); + + { + Variant v{123}; + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isInt()); + ASSERT_EQ(123, v.asInt()); + } + + { + Variant v{1.1}; + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isInt()); + ASSERT_EQ(42, v.asInt()); + } } TEST(Argument, validateDouble) { Argument a = Argument::Double("a"); + ASSERT_FALSE(a.hasDefault); + { Variant v{123}; ASSERT_TRUE(a.validate(v, logger)); @@ -112,7 +171,7 @@ TEST(Argument, validateDouble) ASSERT_TRUE(v.isDouble()); ASSERT_EQ(1.1, v.asDouble()); } - + { Variant v{"1.0"}; ASSERT_FALSE(a.validate(v, logger)); @@ -125,16 +184,37 @@ TEST(Argument, validateDoubleDefault) { Argument a = Argument::Double("a", 42.0); - Variant v{"1.0"}; - ASSERT_FALSE(a.validate(v, logger)); - ASSERT_TRUE(v.isDouble()); - ASSERT_EQ(42.0, v.asDouble()); + ASSERT_TRUE(a.hasDefault); + ASSERT_EQ(42.0, a.defaultValue.asDouble()); + + { + Variant v{123}; + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isDouble()); + ASSERT_EQ(123.0, v.asDouble()); + } + + { + Variant v{1.1}; + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isDouble()); + ASSERT_EQ(1.1, v.asDouble()); + } + + { + Variant v{"1.0"}; + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isDouble()); + ASSERT_EQ(42.0, v.asDouble()); + } } TEST(Argument, validateString) { Argument a = Argument::String("a"); + ASSERT_FALSE(a.hasDefault); + { Variant v{"test"}; ASSERT_TRUE(a.validate(v, logger)); @@ -182,6 +262,44 @@ TEST(Argument, validateStringDefault) { Argument a = Argument::String("a", "test2"); + ASSERT_TRUE(a.hasDefault); + ASSERT_EQ("test2", a.defaultValue.asString()); + + { + Variant v{"test"}; + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isString()); + ASSERT_EQ("test", v.asString()); + } + + { + Variant v{true}; + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isString()); + ASSERT_EQ("true", v.asString()); + } + + { + Variant v{nullptr}; + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isString()); + ASSERT_EQ("null", v.asString()); + } + + { + Variant v{42}; + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isString()); + ASSERT_EQ("42", v.asString()); + } + + { + Variant v{42.5}; + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isString()); + ASSERT_EQ("42.5", v.asString()); + } + { Variant v{{1, 2, 3}}; ASSERT_FALSE(a.validate(v, logger)); @@ -190,5 +308,300 @@ TEST(Argument, validateStringDefault) } } +TEST(Argument, validateObject) +{ + Manager mgr; + Argument a = Argument::Object("a", RttiTypes::TestManaged1); + + ASSERT_FALSE(a.hasDefault); + + { + Rooted<Managed> m{new Managed(mgr)}; + Variant v(m); + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isObject()); + ASSERT_EQ(nullptr, v.asObject()); + } + + { + Rooted<TestManaged1> m{new TestManaged1(mgr)}; + Variant v(m); + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isObject()); + ASSERT_EQ(m, v.asObject()); + } + + { + Rooted<TestManaged2> m{new TestManaged2(mgr)}; + Variant v(m); + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isObject()); + ASSERT_EQ(m, v.asObject()); + } + + { + Rooted<TestManaged1> m1{nullptr}; + Variant v(m1); + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isObject()); + ASSERT_EQ(nullptr, v.asObject()); + } + + { + Variant v("test"); + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isObject()); + ASSERT_EQ(nullptr, v.asObject()); + } +} + +TEST(Argument, validateObjectDefault) +{ + Manager mgr; + Argument a = Argument::Object("a", RttiTypes::TestManaged1, nullptr); + + ASSERT_TRUE(a.hasDefault); + ASSERT_TRUE(a.defaultValue.isObject()); + ASSERT_EQ(nullptr, a.defaultValue.asObject()); + + { + Rooted<Managed> m{new Managed(mgr)}; + Variant v(m); + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isObject()); + ASSERT_EQ(nullptr, v.asObject()); + } + + { + Rooted<TestManaged1> m{new TestManaged1(mgr)}; + Variant v(m); + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isObject()); + ASSERT_EQ(m, v.asObject()); + } + + { + Rooted<TestManaged2> m{new TestManaged2(mgr)}; + Variant v(m); + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isObject()); + ASSERT_EQ(m, v.asObject()); + } + + { + Rooted<TestManaged1> m1{nullptr}; + Variant v(m1); + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isObject()); + ASSERT_EQ(nullptr, v.asObject()); + } + + { + Variant v("test"); + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isObject()); + ASSERT_EQ(nullptr, v.asObject()); + } +} + +static std::shared_ptr<Function> helloWorldFun{new Method<void>{[]( + const Variant::arrayType &arr, void *) { return Variant{"Hello World"}; }}}; + +static std::shared_ptr<Function> goodbyeWorldFun{ + new Method<void>{[](const Variant::arrayType &arr, + void *) { return Variant{"Goodbye Cruel World"}; }}}; + +TEST(Argument, validateFunction) +{ + Argument a = Argument::Function("a"); + + ASSERT_FALSE(a.hasDefault); + + { + Variant v = Variant::fromFunction(helloWorldFun); + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isFunction()); + ASSERT_EQ("Hello World", v.asFunction()->call().asString()); + } + + { + Variant v{"foo"}; + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isFunction()); + ASSERT_TRUE(v.asFunction()->call().isNull()); + } +} + +TEST(Argument, validateFunctionDefault) +{ + Argument a = Argument::Function("a", goodbyeWorldFun); + + ASSERT_TRUE(a.hasDefault); + ASSERT_TRUE(a.defaultValue.isFunction()); + ASSERT_EQ(goodbyeWorldFun, a.defaultValue.asFunction()); + + { + Variant v = Variant::fromFunction(helloWorldFun); + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isFunction()); + ASSERT_EQ("Hello World", v.asFunction()->call().asString()); + } + + { + Variant v{"foo"}; + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isFunction()); + ASSERT_EQ("Goodbye Cruel World", v.asFunction()->call().asString()); + } +} + +TEST(Argument, validateArray) +{ + Argument a = Argument::Array("a"); + + ASSERT_FALSE(a.hasDefault); + + { + Variant::arrayType arr{1, "a", nullptr}; + Variant v{arr}; + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isArray()); + ASSERT_EQ(arr, v.asArray()); + } + + { + Variant v{"foo"}; + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isArray()); + ASSERT_EQ(Variant::arrayType{}, v.asArray()); + } +} + +TEST(Argument, validateArrayDefault) +{ + Variant::arrayType arrDefault{1, "a", nullptr}; + Argument a = Argument::Array("a", arrDefault); + + ASSERT_TRUE(a.hasDefault); + ASSERT_TRUE(a.defaultValue.isArray()); + ASSERT_EQ(arrDefault, a.defaultValue.asArray()); + + { + Variant::arrayType arr{"test1", 42.5}; + Variant v{arr}; + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isArray()); + ASSERT_EQ(arr, v.asArray()); + } + + { + Variant v{"foo"}; + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isArray()); + ASSERT_EQ(arrDefault, v.asArray()); + } +} + +TEST(Argument, validateArrayInner) +{ + Argument a = Argument::Array("a", RttiTypes::String); + + ASSERT_FALSE(a.hasDefault); + + { + Variant::arrayType arr{1, "a", nullptr}; + Variant v{arr}; + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isArray()); + ASSERT_EQ(Variant::arrayType({"1", "a", "null"}), v.asArray()); + } + + { + Variant::arrayType arr{1, "a", Variant::fromObject(nullptr)}; + Variant v{arr}; + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isArray()); + ASSERT_EQ(Variant::arrayType({"1", "a", ""}), v.asArray()); + } + + { + Variant v{"foo"}; + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isArray()); + ASSERT_EQ(Variant::arrayType{}, v.asArray()); + } +} + +TEST(Argument, validateArrayInnerDefault) +{ + Variant::arrayType arrDefault{1, "a", nullptr}; + Argument a = Argument::Array("a", RttiTypes::String, arrDefault); + + ASSERT_TRUE(a.hasDefault); + ASSERT_TRUE(a.defaultValue.isArray()); + ASSERT_EQ(arrDefault, a.defaultValue.asArray()); + + { + Variant::arrayType arr{"test1", 42.5}; + Variant v{arr}; + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isArray()); + ASSERT_EQ(Variant::arrayType({"test1", "42.5"}), v.asArray()); + } + + { + Variant v{"foo"}; + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isArray()); + ASSERT_EQ(arrDefault, v.asArray()); + } +} + +TEST(Argument, validateMap) +{ + Argument a = Argument::Map("a"); + + ASSERT_FALSE(a.hasDefault); + + { + Variant::mapType map{{"key1", 1}, {"key2", "a"}, {"key3", nullptr}}; + Variant v{map}; + + ASSERT_TRUE(a.validate(v, logger)); + ASSERT_TRUE(v.isMap()); + ASSERT_EQ(map, v.asMap()); + } + + { + Variant v{"foo"}; + + ASSERT_FALSE(a.validate(v, logger)); + ASSERT_TRUE(v.isMap()); + ASSERT_EQ(Variant::mapType{}, v.asMap()); + } +} } |