summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/core/common/ArgumentTest.cpp12
-rw-r--r--test/core/common/PropertyTest.cpp6
-rw-r--r--test/core/common/RttiTest.cpp102
-rw-r--r--test/core/common/VariantConverterTest.cpp74
-rw-r--r--test/core/common/VariantTest.cpp16
-rw-r--r--test/core/managed/ManagedTest.cpp16
-rw-r--r--test/core/model/DomainTest.cpp38
-rw-r--r--test/core/model/NodeTest.cpp36
-rw-r--r--test/core/model/TestAdvanced.hpp2
-rw-r--r--test/core/model/TestDocumentBuilder.hpp12
-rw-r--r--test/core/model/TypesystemTest.cpp276
-rw-r--r--test/plugins/xml/XmlParserTest.cpp6
12 files changed, 298 insertions, 298 deletions
diff --git a/test/core/common/ArgumentTest.cpp b/test/core/common/ArgumentTest.cpp
index 43574c1..0a2dcfa 100644
--- a/test/core/common/ArgumentTest.cpp
+++ b/test/core/common/ArgumentTest.cpp
@@ -367,7 +367,7 @@ TEST(Argument, validateStringDefault)
TEST(Argument, validateObject)
{
Manager mgr;
- Argument a = Argument::Object("a", RttiTypes::TestManaged1);
+ Argument a = Argument::Object("a", &RttiTypes::TestManaged1);
ASSERT_FALSE(a.hasDefault());
@@ -419,7 +419,7 @@ TEST(Argument, validateObject)
TEST(Argument, validateObjectDefault)
{
Manager mgr;
- Argument a = Argument::Object("a", RttiTypes::TestManaged1, nullptr);
+ Argument a = Argument::Object("a", &RttiTypes::TestManaged1, nullptr);
ASSERT_TRUE(a.hasDefault());
ASSERT_TRUE(a.getDefaultValue().isObject());
@@ -578,7 +578,7 @@ TEST(Argument, validateArrayDefault)
TEST(Argument, validateArrayInner)
{
- Argument a = Argument::Array("a", RttiTypes::String);
+ Argument a = Argument::Array("a", &RttiTypes::String);
ASSERT_FALSE(a.hasDefault());
@@ -612,7 +612,7 @@ TEST(Argument, validateArrayInner)
TEST(Argument, validateArrayInnerDefault)
{
Variant::arrayType arrDefault{1, "a", nullptr};
- Argument a = Argument::Array("a", RttiTypes::String, arrDefault);
+ Argument a = Argument::Array("a", &RttiTypes::String, arrDefault);
ASSERT_TRUE(a.hasDefault());
ASSERT_TRUE(a.getDefaultValue().isArray());
@@ -698,7 +698,7 @@ TEST(Argument, validateMapDefault)
TEST(Argument, validateMapInnerType)
{
- Argument a = Argument::Map("a", RttiTypes::String);
+ Argument a = Argument::Map("a", &RttiTypes::String);
ASSERT_FALSE(a.hasDefault());
@@ -737,7 +737,7 @@ TEST(Argument, validateMapInnerType)
TEST(Argument, validateMapInnerTypeDefault)
{
Variant::mapType mapDefault{{"key1", "1"}};
- Argument a = Argument::Map("a", RttiTypes::String, mapDefault);
+ Argument a = Argument::Map("a", &RttiTypes::String, mapDefault);
ASSERT_TRUE(a.hasDefault());
ASSERT_TRUE(a.getDefaultValue().isMap());
diff --git a/test/core/common/PropertyTest.cpp b/test/core/common/PropertyTest.cpp
index 0f3d74e..f57b4c0 100644
--- a/test/core/common/PropertyTest.cpp
+++ b/test/core/common/PropertyTest.cpp
@@ -62,7 +62,7 @@ TEST(Getter, construction)
TEST(Getter, validation)
{
std::shared_ptr<PropertyType> type =
- std::make_shared<PropertyType>(RttiTypes::Int);
+ std::make_shared<PropertyType>(&RttiTypes::Int);
TestObject obj{123};
{
@@ -111,7 +111,7 @@ TEST(Setter, construction)
TEST(Setter, validation)
{
std::shared_ptr<PropertyType> type =
- std::make_shared<PropertyType>(RttiTypes::Int);
+ std::make_shared<PropertyType>(&RttiTypes::Int);
TestObject obj{123};
Setter<TestObject> setter{TestObject::setA};
@@ -164,7 +164,7 @@ TEST(Property, construction)
}
{
- Property<TestObject> property{RttiTypes::Int, TestObject::getA,
+ Property<TestObject> property{&RttiTypes::Int, TestObject::getA,
TestObject::setA};
ASSERT_FALSE(property.isReadonly());
diff --git a/test/core/common/RttiTest.cpp b/test/core/common/RttiTest.cpp
index 019750a..7fcfd11 100644
--- a/test/core/common/RttiTest.cpp
+++ b/test/core/common/RttiTest.cpp
@@ -59,63 +59,63 @@ const Rtti Type7 = RttiBuilder<RttiTestClass7>{"Type7"}.parent(&Type6);
TEST(Rtti, isa)
{
- ASSERT_TRUE(Type1.isa(Type1));
- ASSERT_FALSE(Type1.isa(Type2));
- ASSERT_FALSE(Type1.isa(Type3));
- ASSERT_FALSE(Type1.isa(Type4));
-
- ASSERT_FALSE(Type2.isa(Type1));
- ASSERT_TRUE(Type2.isa(Type2));
- ASSERT_FALSE(Type2.isa(Type3));
- ASSERT_FALSE(Type2.isa(Type4));
-
- ASSERT_TRUE(Type3.isa(Type1));
- ASSERT_FALSE(Type3.isa(Type2));
- ASSERT_TRUE(Type3.isa(Type3));
- ASSERT_FALSE(Type3.isa(Type4));
-
- ASSERT_TRUE(Type4.isa(Type1));
- ASSERT_TRUE(Type4.isa(Type2));
- ASSERT_TRUE(Type4.isa(Type3));
- ASSERT_TRUE(Type4.isa(Type4));
+ ASSERT_TRUE(Type1.isa(&Type1));
+ ASSERT_FALSE(Type1.isa(&Type2));
+ ASSERT_FALSE(Type1.isa(&Type3));
+ ASSERT_FALSE(Type1.isa(&Type4));
+
+ ASSERT_FALSE(Type2.isa(&Type1));
+ ASSERT_TRUE(Type2.isa(&Type2));
+ ASSERT_FALSE(Type2.isa(&Type3));
+ ASSERT_FALSE(Type2.isa(&Type4));
+
+ ASSERT_TRUE(Type3.isa(&Type1));
+ ASSERT_FALSE(Type3.isa(&Type2));
+ ASSERT_TRUE(Type3.isa(&Type3));
+ ASSERT_FALSE(Type3.isa(&Type4));
+
+ ASSERT_TRUE(Type4.isa(&Type1));
+ ASSERT_TRUE(Type4.isa(&Type2));
+ ASSERT_TRUE(Type4.isa(&Type3));
+ ASSERT_TRUE(Type4.isa(&Type4));
}
TEST(Rtti, composedOf)
{
std::vector<const Rtti *> types{&Type1, &Type2, &Type3, &Type4};
for (auto t : types) {
- ASSERT_FALSE(t->composedOf(Type1));
- ASSERT_FALSE(t->composedOf(Type2));
- ASSERT_FALSE(t->composedOf(Type3));
- ASSERT_FALSE(t->composedOf(Type4));
- ASSERT_FALSE(t->composedOf(Type5));
- ASSERT_FALSE(t->composedOf(Type6));
- ASSERT_FALSE(t->composedOf(Type7));
+ ASSERT_FALSE(t->composedOf(&Type1));
+ ASSERT_FALSE(t->composedOf(&Type2));
+ ASSERT_FALSE(t->composedOf(&Type3));
+ ASSERT_FALSE(t->composedOf(&Type4));
+ ASSERT_FALSE(t->composedOf(&Type5));
+ ASSERT_FALSE(t->composedOf(&Type6));
+ ASSERT_FALSE(t->composedOf(&Type7));
}
- ASSERT_TRUE(Type5.composedOf(Type1));
- ASSERT_FALSE(Type5.composedOf(Type2));
- ASSERT_FALSE(Type5.composedOf(Type3));
- ASSERT_FALSE(Type5.composedOf(Type4));
- ASSERT_FALSE(Type5.composedOf(Type5));
- ASSERT_TRUE(Type5.composedOf(Type6));
- ASSERT_TRUE(Type5.composedOf(Type7));
-
- ASSERT_TRUE(Type6.composedOf(Type1));
- ASSERT_FALSE(Type6.composedOf(Type2));
- ASSERT_FALSE(Type6.composedOf(Type3));
- ASSERT_FALSE(Type6.composedOf(Type4));
- ASSERT_FALSE(Type6.composedOf(Type5));
- ASSERT_FALSE(Type6.composedOf(Type6));
- ASSERT_FALSE(Type6.composedOf(Type7));
-
- ASSERT_TRUE(Type7.composedOf(Type1));
- ASSERT_FALSE(Type7.composedOf(Type2));
- ASSERT_FALSE(Type7.composedOf(Type3));
- ASSERT_FALSE(Type7.composedOf(Type4));
- ASSERT_FALSE(Type7.composedOf(Type5));
- ASSERT_FALSE(Type7.composedOf(Type6));
- ASSERT_FALSE(Type7.composedOf(Type7));
+ ASSERT_TRUE(Type5.composedOf(&Type1));
+ ASSERT_FALSE(Type5.composedOf(&Type2));
+ ASSERT_FALSE(Type5.composedOf(&Type3));
+ ASSERT_FALSE(Type5.composedOf(&Type4));
+ ASSERT_FALSE(Type5.composedOf(&Type5));
+ ASSERT_TRUE(Type5.composedOf(&Type6));
+ ASSERT_TRUE(Type5.composedOf(&Type7));
+
+ ASSERT_TRUE(Type6.composedOf(&Type1));
+ ASSERT_FALSE(Type6.composedOf(&Type2));
+ ASSERT_FALSE(Type6.composedOf(&Type3));
+ ASSERT_FALSE(Type6.composedOf(&Type4));
+ ASSERT_FALSE(Type6.composedOf(&Type5));
+ ASSERT_FALSE(Type6.composedOf(&Type6));
+ ASSERT_FALSE(Type6.composedOf(&Type7));
+
+ ASSERT_TRUE(Type7.composedOf(&Type1));
+ ASSERT_FALSE(Type7.composedOf(&Type2));
+ ASSERT_FALSE(Type7.composedOf(&Type3));
+ ASSERT_FALSE(Type7.composedOf(&Type4));
+ ASSERT_FALSE(Type7.composedOf(&Type5));
+ ASSERT_FALSE(Type7.composedOf(&Type6));
+ ASSERT_FALSE(Type7.composedOf(&Type7));
}
class RttiMethodTestClass1 {
@@ -218,12 +218,12 @@ public:
};
static const Rtti PType1 = RttiBuilder<RttiPropertyTestClass1>{
- "PType1"}.property("a", {RttiTypes::Int, RttiPropertyTestClass1::getA,
+ "PType1"}.property("a", {&RttiTypes::Int, RttiPropertyTestClass1::getA,
RttiPropertyTestClass1::setA});
static const Rtti PType2 =
RttiBuilder<RttiPropertyTestClass2>{"PType2"}.parent(&PType1).property(
- "b", {RttiTypes::Int, RttiPropertyTestClass2::getB,
+ "b", {&RttiTypes::Int, RttiPropertyTestClass2::getB,
RttiPropertyTestClass2::setB});
TEST(Rtti, properties)
diff --git a/test/core/common/VariantConverterTest.cpp b/test/core/common/VariantConverterTest.cpp
index ab18f14..9654a7b 100644
--- a/test/core/common/VariantConverterTest.cpp
+++ b/test/core/common/VariantConverterTest.cpp
@@ -249,7 +249,7 @@ TEST(VariantConverter, toString)
}
static void assertArrayConversion(Variant conv, Variant expected,
- bool expectedSuccess, const Rtti &innerType,
+ bool expectedSuccess, const Rtti *innerType,
VariantConverter::Mode mode, Logger &logger)
{
EXPECT_EQ(expectedSuccess,
@@ -276,48 +276,48 @@ TEST(VariantConverter, toArray)
Variant C = card;
// in safe mode only array to array conversion should be possible.
- assertArrayConversion(n, nullptr, false, RttiTypes::None,
+ assertArrayConversion(n, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertArrayConversion(b, nullptr, false, RttiTypes::None,
+ assertArrayConversion(b, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertArrayConversion(i, nullptr, false, RttiTypes::None,
+ assertArrayConversion(i, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertArrayConversion(d, nullptr, false, RttiTypes::None,
+ assertArrayConversion(d, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertArrayConversion(s, nullptr, false, RttiTypes::None,
+ assertArrayConversion(s, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertArrayConversion(A, A, true, RttiTypes::None,
+ assertArrayConversion(A, A, true, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertArrayConversion(M, nullptr, false, RttiTypes::None,
+ assertArrayConversion(M, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertArrayConversion(C, nullptr, false, RttiTypes::None,
+ assertArrayConversion(C, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
// in all mode more should be possible.
- assertArrayConversion(n, Variant::arrayType{n}, true, RttiTypes::None,
+ assertArrayConversion(n, Variant::arrayType{n}, true, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertArrayConversion(b, Variant::arrayType{b}, true, RttiTypes::None,
+ assertArrayConversion(b, Variant::arrayType{b}, true, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertArrayConversion(i, Variant::arrayType{i}, true, RttiTypes::None,
+ assertArrayConversion(i, Variant::arrayType{i}, true, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertArrayConversion(d, Variant::arrayType{d}, true, RttiTypes::None,
+ assertArrayConversion(d, Variant::arrayType{d}, true, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertArrayConversion(s, Variant::arrayType{s}, true, RttiTypes::None,
+ assertArrayConversion(s, Variant::arrayType{s}, true, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertArrayConversion(A, A, true, RttiTypes::None,
+ assertArrayConversion(A, A, true, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertArrayConversion(M, Variant::arrayType{M}, true, RttiTypes::None,
+ assertArrayConversion(M, Variant::arrayType{M}, true, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertArrayConversion(C, Variant::arrayType{C}, true, RttiTypes::None,
+ assertArrayConversion(C, Variant::arrayType{C}, true, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
// as an example also check the inner type converion
assertArrayConversion(
A, Variant::arrayType{Variant(1), Variant(6), Variant(2), Variant(9)},
- true, RttiTypes::Int, VariantConverter::Mode::ALL, logger);
+ true, &RttiTypes::Int, VariantConverter::Mode::ALL, logger);
}
static void assertMapConversion(Variant conv, Variant expected,
- bool expectedSuccess, const Rtti &innerType,
+ bool expectedSuccess, const Rtti *innerType,
VariantConverter::Mode mode, Logger &logger)
{
EXPECT_EQ(expectedSuccess,
@@ -344,39 +344,39 @@ TEST(VariantConverter, toMap)
Variant C = card;
// in safe mode only map to map conversion should be possible.
- assertMapConversion(n, nullptr, false, RttiTypes::None,
+ assertMapConversion(n, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertMapConversion(b, nullptr, false, RttiTypes::None,
+ assertMapConversion(b, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertMapConversion(i, nullptr, false, RttiTypes::None,
+ assertMapConversion(i, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertMapConversion(d, nullptr, false, RttiTypes::None,
+ assertMapConversion(d, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertMapConversion(s, nullptr, false, RttiTypes::None,
+ assertMapConversion(s, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertMapConversion(A, nullptr, false, RttiTypes::None,
+ assertMapConversion(A, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertMapConversion(M, M, true, RttiTypes::None,
+ assertMapConversion(M, M, true, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
- assertMapConversion(C, nullptr, false, RttiTypes::None,
+ assertMapConversion(C, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::SAFE, logger);
// in all mode that should be the same.
- assertMapConversion(n, nullptr, false, RttiTypes::None,
+ assertMapConversion(n, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertMapConversion(b, nullptr, false, RttiTypes::None,
+ assertMapConversion(b, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertMapConversion(i, nullptr, false, RttiTypes::None,
+ assertMapConversion(i, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertMapConversion(d, nullptr, false, RttiTypes::None,
+ assertMapConversion(d, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertMapConversion(s, nullptr, false, RttiTypes::None,
+ assertMapConversion(s, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertMapConversion(A, nullptr, false, RttiTypes::None,
+ assertMapConversion(A, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertMapConversion(M, M, true, RttiTypes::None,
+ assertMapConversion(M, M, true, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
- assertMapConversion(C, nullptr, false, RttiTypes::None,
+ assertMapConversion(C, nullptr, false, &RttiTypes::None,
VariantConverter::Mode::ALL, logger);
// but we should be able to convert the inner type.
@@ -384,14 +384,14 @@ TEST(VariantConverter, toMap)
{"i", Variant(6)},
{"d", Variant(2)},
{"s", Variant(9)}},
- true, RttiTypes::Int, VariantConverter::Mode::ALL,
+ true, &RttiTypes::Int, VariantConverter::Mode::ALL,
logger);
// which should not work in SAFE mode.
assertMapConversion(M, Variant::mapType{{"b", Variant(1)},
{"i", Variant(6)},
{"d", Variant(2)},
{"s", Variant(9)}},
- false, RttiTypes::Int, VariantConverter::Mode::SAFE,
+ false, &RttiTypes::Int, VariantConverter::Mode::SAFE,
logger);
}
diff --git a/test/core/common/VariantTest.cpp b/test/core/common/VariantTest.cpp
index 6381607..ee04034 100644
--- a/test/core/common/VariantTest.cpp
+++ b/test/core/common/VariantTest.cpp
@@ -40,7 +40,7 @@ TEST(Variant, nullValue)
ASSERT_TRUE(v.isNull());
ASSERT_EQ(VariantType::NULLPTR, v.getType());
- ASSERT_EQ(&RttiTypes::Nullptr, &v.getRtti());
+ ASSERT_EQ(&RttiTypes::Nullptr, v.getRtti());
}
TEST(Variant, booleanValue)
@@ -57,7 +57,7 @@ TEST(Variant, booleanValue)
ASSERT_TRUE(v.isBool());
ASSERT_TRUE(v.asBool());
ASSERT_EQ(VariantType::BOOL, v.getType());
- ASSERT_EQ(&RttiTypes::Bool, &v.getRtti());
+ ASSERT_EQ(&RttiTypes::Bool, v.getRtti());
v = nullptr;
ASSERT_FALSE(v.isBool());
@@ -73,7 +73,7 @@ TEST(Variant, intValue)
ASSERT_TRUE(v.isInt());
ASSERT_EQ(43, v.asInt());
ASSERT_EQ(VariantType::INT, v.getType());
- ASSERT_EQ(&RttiTypes::Int, &v.getRtti());
+ ASSERT_EQ(&RttiTypes::Int, v.getRtti());
v = false;
ASSERT_FALSE(v.isInt());
@@ -92,7 +92,7 @@ TEST(Variant, doubleValue)
ASSERT_TRUE(v.isDouble());
ASSERT_EQ(43.5, v.asDouble());
ASSERT_EQ(VariantType::DOUBLE, v.getType());
- ASSERT_EQ(&RttiTypes::Double, &v.getRtti());
+ ASSERT_EQ(&RttiTypes::Double, v.getRtti());
}
TEST(Variant, stringValue)
@@ -105,7 +105,7 @@ TEST(Variant, stringValue)
ASSERT_TRUE(v.isString());
ASSERT_EQ("Goodbye Cruel World", v.asString());
ASSERT_EQ(VariantType::STRING, v.getType());
- ASSERT_EQ(&RttiTypes::String, &v.getRtti());
+ ASSERT_EQ(&RttiTypes::String, v.getRtti());
v = 42;
ASSERT_FALSE(v.isString());
@@ -134,7 +134,7 @@ TEST(Variant, cardinalityValue)
ASSERT_TRUE(v.isCardinality());
ASSERT_EQ(VariantType::CARDINALITY, v.getType());
- ASSERT_EQ(&RttiTypes::Cardinality, &v.getRtti());
+ ASSERT_EQ(&RttiTypes::Cardinality, v.getRtti());
}
@@ -147,7 +147,7 @@ TEST(Variant, arrayValue)
ASSERT_TRUE(v.isArray());
ASSERT_EQ(VariantType::ARRAY, v.getType());
- ASSERT_EQ(&RttiTypes::Array, &v.getRtti());
+ ASSERT_EQ(&RttiTypes::Array, v.getRtti());
}
TEST(Variant, mapValue)
@@ -165,7 +165,7 @@ TEST(Variant, mapValue)
ASSERT_TRUE(v.isMap());
ASSERT_EQ(VariantType::MAP, v.getType());
- ASSERT_EQ(&RttiTypes::Map, &v.getRtti());
+ ASSERT_EQ(&RttiTypes::Map, v.getRtti());
}
TEST(Variant, relationalOperators)
diff --git a/test/core/managed/ManagedTest.cpp b/test/core/managed/ManagedTest.cpp
index c2b19cf..653e7ef 100644
--- a/test/core/managed/ManagedTest.cpp
+++ b/test/core/managed/ManagedTest.cpp
@@ -93,14 +93,14 @@ TEST(Managed, type)
Rooted<TypeTestManaged4> m4{new TypeTestManaged4(mgr)};
Rooted<TypeTestManaged5> m5{new TypeTestManaged5(mgr)};
- ASSERT_EQ(&Type1, &m1->type());
- ASSERT_EQ(&Type2, &m2->type());
- ASSERT_EQ(&Type3, &m3->type());
- ASSERT_EQ(&Type4, &m4->type());
- ASSERT_EQ(&RttiTypes::None, &m5->type());
-
- ASSERT_EQ(&Type1, &typeOf<TypeTestManaged1>());
- ASSERT_EQ(&Type1, &typeOf(*m1));
+ ASSERT_EQ(&Type1, m1->type());
+ ASSERT_EQ(&Type2, m2->type());
+ ASSERT_EQ(&Type3, m3->type());
+ ASSERT_EQ(&Type4, m4->type());
+ ASSERT_EQ(&RttiTypes::None, m5->type());
+
+ ASSERT_EQ(&Type1, typeOf<TypeTestManaged1>());
+ ASSERT_EQ(&Type1, typeOf(*m1));
}
class TestManagedEventOwner : public TestManaged {
diff --git a/test/core/model/DomainTest.cpp b/test/core/model/DomainTest.cpp
index 0c85d10..32ef7f0 100644
--- a/test/core/model/DomainTest.cpp
+++ b/test/core/model/DomainTest.cpp
@@ -28,7 +28,7 @@
namespace ousia {
-void assert_path(const ResolutionResult &res, const Rtti &expected_type,
+void assert_path(const ResolutionResult &res, const Rtti *expected_type,
std::vector<std::string> expected_path)
{
// Check class/type
@@ -50,41 +50,41 @@ TEST(Domain, testDomainResolving)
std::vector<ResolutionResult> res;
// There is one domain called "book"
- res = domain->resolve(RttiTypes::Domain, "book");
+ res = domain->resolve(&RttiTypes::Domain, "book");
ASSERT_EQ(1U, res.size());
- assert_path(res[0], RttiTypes::Domain, {"book"});
+ assert_path(res[0], &RttiTypes::Domain, {"book"});
// There is one domain called "book"
- res = domain->resolve(RttiTypes::StructuredClass, "book");
+ res = domain->resolve(&RttiTypes::StructuredClass, "book");
ASSERT_EQ(1U, res.size());
- assert_path(res[0], RttiTypes::StructuredClass, {"book", "book"});
+ assert_path(res[0], &RttiTypes::StructuredClass, {"book", "book"});
// If we explicitly ask for the "book, book" path, then only the
// StructuredClass should be returned.
- res = domain->resolve(RttiTypes::Domain,
+ res = domain->resolve(&RttiTypes::Domain,
std::vector<std::string>{"book", "book"});
ASSERT_EQ(0U, res.size());
- res = domain->resolve(RttiTypes::StructuredClass,
+ res = domain->resolve(&RttiTypes::StructuredClass,
std::vector<std::string>{"book", "book"});
ASSERT_EQ(1U, res.size());
// If we ask for "section" the result should be unique as well.
- res = domain->resolve(RttiTypes::StructuredClass, "section");
+ res = domain->resolve(&RttiTypes::StructuredClass, "section");
ASSERT_EQ(1U, res.size());
- assert_path(res[0], RttiTypes::StructuredClass, {"book", "section"});
+ assert_path(res[0], &RttiTypes::StructuredClass, {"book", "section"});
// If we ask for "paragraph" it is referenced two times in the Domain graph,
// but should be returned only once.
- res = domain->resolve(RttiTypes::StructuredClass, "paragraph");
+ res = domain->resolve(&RttiTypes::StructuredClass, "paragraph");
ASSERT_EQ(1U, res.size());
- assert_path(res[0], RttiTypes::StructuredClass, {"book", "paragraph"});
+ assert_path(res[0], &RttiTypes::StructuredClass, {"book", "paragraph"});
}
Rooted<StructuredClass> getClass(const std::string name, Handle<Domain> dom)
{
std::vector<ResolutionResult> res =
- dom->resolve(RttiTypes::StructuredClass, name);
+ dom->resolve(&RttiTypes::StructuredClass, name);
return res[0].node.cast<StructuredClass>();
}
@@ -103,17 +103,17 @@ TEST(Descriptor, pathTo)
// get the path in between.
std::vector<Rooted<Node>> path = book->pathTo(section);
ASSERT_EQ(1U, path.size());
- ASSERT_TRUE(path[0]->isa(RttiTypes::FieldDescriptor));
+ ASSERT_TRUE(path[0]->isa(&RttiTypes::FieldDescriptor));
// get the text node.
Rooted<StructuredClass> text = getClass("text", domain);
// get the path between book and text via paragraph.
path = book->pathTo(text);
ASSERT_EQ(3U, path.size());
- ASSERT_TRUE(path[0]->isa(RttiTypes::FieldDescriptor));
- ASSERT_TRUE(path[1]->isa(RttiTypes::StructuredClass));
+ ASSERT_TRUE(path[0]->isa(&RttiTypes::FieldDescriptor));
+ ASSERT_TRUE(path[1]->isa(&RttiTypes::StructuredClass));
ASSERT_EQ("paragraph", path[1]->getName());
- ASSERT_TRUE(path[2]->isa(RttiTypes::FieldDescriptor));
+ ASSERT_TRUE(path[2]->isa(&RttiTypes::FieldDescriptor));
// get the subsection node.
Rooted<StructuredClass> subsection = getClass("subsection", domain);
@@ -208,11 +208,11 @@ TEST(Descriptor, pathToAdvanced)
// and now we should be able to find the shortest path as suggested
std::vector<Rooted<Node>> path = start->pathTo(target);
ASSERT_EQ(3U, path.size());
- ASSERT_TRUE(path[0]->isa(RttiTypes::FieldDescriptor));
+ ASSERT_TRUE(path[0]->isa(&RttiTypes::FieldDescriptor));
ASSERT_EQ("second", path[0]->getName());
- ASSERT_TRUE(path[1]->isa(RttiTypes::StructuredClass));
+ ASSERT_TRUE(path[1]->isa(&RttiTypes::StructuredClass));
ASSERT_EQ("B", path[1]->getName());
- ASSERT_TRUE(path[2]->isa(RttiTypes::FieldDescriptor));
+ ASSERT_TRUE(path[2]->isa(&RttiTypes::FieldDescriptor));
ASSERT_EQ("$default", path[2]->getName());
}
diff --git a/test/core/model/NodeTest.cpp b/test/core/model/NodeTest.cpp
index d9ca5bb..cdcd018 100644
--- a/test/core/model/NodeTest.cpp
+++ b/test/core/model/NodeTest.cpp
@@ -85,18 +85,18 @@ TEST(Node, resolveCompositaSimple)
child1->addCompositum(new TestNode(mgr, "child11"));
std::vector<ResolutionResult> res;
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"root", "child1", "child11"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child11 == res[0].node);
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"child1", "child11"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child11 == res[0].node);
res =
- root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child11"});
+ root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child11"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child11 == res[0].node);
}
@@ -111,18 +111,18 @@ TEST(Node, resolveCompositaDouble)
child1->addCompositum(new TestNode(mgr, "child11"));
std::vector<ResolutionResult> res;
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"root", "child1", "child11"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child11 == res[0].node);
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"child1", "child11"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child11 == res[0].node);
res =
- root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child11"});
+ root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child11"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child11 == res[0].node);
}
@@ -141,14 +141,14 @@ TEST(Node, resolveAmbigousComposita)
child12->addCompositum(new TestNode(mgr, "child11"));
std::vector<ResolutionResult> res;
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"child1", "child11"});
ASSERT_EQ(2U, res.size());
ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node);
ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node);
res =
- root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child11"});
+ root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child11"});
ASSERT_EQ(2U, res.size());
ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node);
ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node);
@@ -168,30 +168,30 @@ TEST(Node, resolveReferences)
child12->addCompositum(new TestNode(mgr, "child11"));
std::vector<ResolutionResult> res;
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"a", "child1", "child11"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child11 == res[0].node);
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"b", "child1", "child11"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child112 == res[0].node);
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"child1", "child11"});
ASSERT_EQ(2U, res.size());
ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node);
ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node);
res =
- root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child11"});
+ root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child11"});
ASSERT_EQ(2U, res.size());
ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node);
ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node);
res =
- root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child1"});
+ root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child1"});
ASSERT_EQ(2U, res.size());
ASSERT_TRUE(child1 == res[0].node || child1 == res[1].node);
ASSERT_TRUE(child12 == res[0].node || child12 == res[1].node);
@@ -212,31 +212,31 @@ TEST(Node, resolveReferencesAndComposita)
Rooted<TestNode> child13 = root->addCompositum(new TestNode(mgr, "child1"));
std::vector<ResolutionResult> res;
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"a", "child1", "child11"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child11 == res[0].node);
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"b", "child1", "child11"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child112 == res[0].node);
- res = root->resolve(RttiTypes::TestNode,
+ res = root->resolve(&RttiTypes::TestNode,
std::vector<std::string>{"child1", "child11"});
ASSERT_EQ(2U, res.size());
ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node);
ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node);
res =
- root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child11"});
+ root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child11"});
ASSERT_EQ(2U, res.size());
ASSERT_TRUE(child11 == res[0].node || child11 == res[1].node);
ASSERT_TRUE(child112 == res[0].node || child112 == res[1].node);
// Resolving for "child1" should not descend into the referenced nodes
res =
- root->resolve(RttiTypes::TestNode, std::vector<std::string>{"child1"});
+ root->resolve(&RttiTypes::TestNode, std::vector<std::string>{"child1"});
ASSERT_EQ(1U, res.size());
ASSERT_TRUE(child13 == res[0].node);
}
diff --git a/test/core/model/TestAdvanced.hpp b/test/core/model/TestAdvanced.hpp
index 5c709f0..915d973 100644
--- a/test/core/model/TestAdvanced.hpp
+++ b/test/core/model/TestAdvanced.hpp
@@ -32,7 +32,7 @@ static Rooted<StructuredClass> resolveDescriptor(Handle<Domain> domain,
{
// use the actual resolve method.
std::vector<ResolutionResult> resolved =
- domain->resolve(RttiTypes::StructuredClass, className);
+ domain->resolve(&RttiTypes::StructuredClass, className);
// take the first valid result.
for (auto &r : resolved) {
return r.node.cast<StructuredClass>();
diff --git a/test/core/model/TestDocumentBuilder.hpp b/test/core/model/TestDocumentBuilder.hpp
index 3d24839..fc76b07 100644
--- a/test/core/model/TestDocumentBuilder.hpp
+++ b/test/core/model/TestDocumentBuilder.hpp
@@ -45,7 +45,7 @@ static std::string getPathString(const Path &path)
static Rooted<Descriptor> resolveDescriptor(Handle<Document> doc,
Logger &logger, const Path &path,
- const Rtti &type)
+ const Rtti *type)
{
// use the actual resolve method.
std::vector<ResolutionResult> resolved = doc->resolve(type, path);
@@ -96,7 +96,7 @@ Rooted<StructuredEntity> buildRootStructuredEntity(
// If we can not find the correct descriptor, we can not build the entity
// either.
Rooted<Descriptor> descriptor =
- resolveDescriptor(document, logger, path, RttiTypes::StructuredClass);
+ resolveDescriptor(document, logger, path, &RttiTypes::StructuredClass);
if (descriptor == nullptr) {
return {nullptr};
}
@@ -146,11 +146,11 @@ Rooted<StructuredEntity> buildStructuredEntity(
// If we can not find the correct descriptor, we can not build the entity
// either.
Rooted<Descriptor> descriptor =
- resolveDescriptor(document, logger, path, RttiTypes::StructuredClass);
+ resolveDescriptor(document, logger, path, &RttiTypes::StructuredClass);
if (descriptor == nullptr) {
return {nullptr};
}
- if (!descriptor->isa(RttiTypes::StructuredClass)) {
+ if (!descriptor->isa(&RttiTypes::StructuredClass)) {
return {nullptr};
logger.error("The descriptor was not an AnnotationClass!");
}
@@ -195,11 +195,11 @@ Rooted<AnnotationEntity> buildAnnotationEntity(
// If we can not find the correct descriptor, we can not build the
// entity either.
Rooted<Descriptor> descriptor =
- resolveDescriptor(document, logger, path, RttiTypes::AnnotationClass);
+ resolveDescriptor(document, logger, path, &RttiTypes::AnnotationClass);
if (descriptor == nullptr) {
return {nullptr};
}
- if (!descriptor->isa(RttiTypes::AnnotationClass)) {
+ if (!descriptor->isa(&RttiTypes::AnnotationClass)) {
return {nullptr};
logger.error("The descriptor was not an AnnotationClass!");
}
diff --git a/test/core/model/TypesystemTest.cpp b/test/core/model/TypesystemTest.cpp
index bf40356..9b5872c 100644
--- a/test/core/model/TypesystemTest.cpp
+++ b/test/core/model/TypesystemTest.cpp
@@ -37,20 +37,20 @@ TEST(StringType, rtti)
Rooted<StringType> strType{new StringType(mgr, nullptr)};
ASSERT_TRUE(strType->isa(typeOf<Type>()));
ASSERT_TRUE(strType->isa(typeOf<Node>()));
- ASSERT_TRUE(strType->isa(RttiTypes::StringType));
- ASSERT_FALSE(strType->composedOf(RttiTypes::Type));
- ASSERT_FALSE(strType->composedOf(RttiTypes::StringType));
- ASSERT_FALSE(strType->composedOf(RttiTypes::IntType));
- ASSERT_FALSE(strType->composedOf(RttiTypes::DoubleType));
- ASSERT_FALSE(strType->composedOf(RttiTypes::BoolType));
- ASSERT_FALSE(strType->composedOf(RttiTypes::EnumType));
- ASSERT_FALSE(strType->composedOf(RttiTypes::StructType));
- ASSERT_FALSE(strType->composedOf(RttiTypes::ArrayType));
- ASSERT_FALSE(strType->composedOf(RttiTypes::UnknownType));
- ASSERT_FALSE(strType->composedOf(RttiTypes::Constant));
- ASSERT_FALSE(strType->composedOf(RttiTypes::Attribute));
- ASSERT_FALSE(strType->composedOf(RttiTypes::Typesystem));
- ASSERT_FALSE(strType->composedOf(RttiTypes::SystemTypesystem));
+ ASSERT_TRUE(strType->isa(&RttiTypes::StringType));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::Type));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::StringType));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::IntType));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::DoubleType));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::BoolType));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::EnumType));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::StructType));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::ArrayType));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::UnknownType));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::Constant));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::Attribute));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::Typesystem));
+ ASSERT_FALSE(strType->composedOf(&RttiTypes::SystemTypesystem));
}
TEST(StringType, creation)
@@ -124,22 +124,22 @@ TEST(IntType, rtti)
{
Manager mgr;
Rooted<IntType> intType{new IntType(mgr, nullptr)};
- ASSERT_TRUE(intType->isa(RttiTypes::IntType));
+ ASSERT_TRUE(intType->isa(&RttiTypes::IntType));
ASSERT_TRUE(intType->isa(typeOf<Type>()));
ASSERT_TRUE(intType->isa(typeOf<Node>()));
- ASSERT_FALSE(intType->composedOf(RttiTypes::Type));
- ASSERT_FALSE(intType->composedOf(RttiTypes::StringType));
- ASSERT_FALSE(intType->composedOf(RttiTypes::IntType));
- ASSERT_FALSE(intType->composedOf(RttiTypes::DoubleType));
- ASSERT_FALSE(intType->composedOf(RttiTypes::BoolType));
- ASSERT_FALSE(intType->composedOf(RttiTypes::EnumType));
- ASSERT_FALSE(intType->composedOf(RttiTypes::StructType));
- ASSERT_FALSE(intType->composedOf(RttiTypes::ArrayType));
- ASSERT_FALSE(intType->composedOf(RttiTypes::UnknownType));
- ASSERT_FALSE(intType->composedOf(RttiTypes::Constant));
- ASSERT_FALSE(intType->composedOf(RttiTypes::Attribute));
- ASSERT_FALSE(intType->composedOf(RttiTypes::Typesystem));
- ASSERT_FALSE(intType->composedOf(RttiTypes::SystemTypesystem));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::Type));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::StringType));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::IntType));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::DoubleType));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::BoolType));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::EnumType));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::StructType));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::ArrayType));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::UnknownType));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::Constant));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::Attribute));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::Typesystem));
+ ASSERT_FALSE(intType->composedOf(&RttiTypes::SystemTypesystem));
}
TEST(IntType, creation)
@@ -177,22 +177,22 @@ TEST(DoubleType, rtti)
{
Manager mgr;
Rooted<DoubleType> doubleType{new DoubleType(mgr, nullptr)};
- ASSERT_TRUE(doubleType->isa(RttiTypes::DoubleType));
+ ASSERT_TRUE(doubleType->isa(&RttiTypes::DoubleType));
ASSERT_TRUE(doubleType->isa(typeOf<Type>()));
ASSERT_TRUE(doubleType->isa(typeOf<Node>()));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::Type));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::StringType));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::IntType));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::DoubleType));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::BoolType));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::EnumType));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::StructType));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::ArrayType));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::UnknownType));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::Constant));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::Attribute));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::Typesystem));
- ASSERT_FALSE(doubleType->composedOf(RttiTypes::SystemTypesystem));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::Type));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::StringType));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::IntType));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::DoubleType));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::BoolType));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::EnumType));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::StructType));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::ArrayType));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::UnknownType));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::Constant));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::Attribute));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::Typesystem));
+ ASSERT_FALSE(doubleType->composedOf(&RttiTypes::SystemTypesystem));
}
TEST(DoubleType, creation)
@@ -237,22 +237,22 @@ TEST(BoolType, rtti)
{
Manager mgr;
Rooted<BoolType> boolType{new BoolType(mgr, nullptr)};
- ASSERT_TRUE(boolType->isa(RttiTypes::BoolType));
+ ASSERT_TRUE(boolType->isa(&RttiTypes::BoolType));
ASSERT_TRUE(boolType->isa(typeOf<Type>()));
ASSERT_TRUE(boolType->isa(typeOf<Node>()));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::Type));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::StringType));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::IntType));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::DoubleType));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::BoolType));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::EnumType));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::StructType));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::ArrayType));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::UnknownType));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::Constant));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::Attribute));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::Typesystem));
- ASSERT_FALSE(boolType->composedOf(RttiTypes::SystemTypesystem));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::Type));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::StringType));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::IntType));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::DoubleType));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::BoolType));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::EnumType));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::StructType));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::ArrayType));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::UnknownType));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::Constant));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::Attribute));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::Typesystem));
+ ASSERT_FALSE(boolType->composedOf(&RttiTypes::SystemTypesystem));
}
TEST(BoolType, creation)
@@ -298,22 +298,22 @@ TEST(EnumType, rtti)
Manager mgr;
Rooted<EnumType> enumType{EnumType::createValidated(
mgr, "enum", nullptr, {"a", "b", "c"}, logger)};
- ASSERT_TRUE(enumType->isa(RttiTypes::EnumType));
+ ASSERT_TRUE(enumType->isa(&RttiTypes::EnumType));
ASSERT_TRUE(enumType->isa(typeOf<Type>()));
ASSERT_TRUE(enumType->isa(typeOf<Node>()));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::Type));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::StringType));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::IntType));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::DoubleType));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::BoolType));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::EnumType));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::StructType));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::ArrayType));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::UnknownType));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::Constant));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::Attribute));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::Typesystem));
- ASSERT_FALSE(enumType->composedOf(RttiTypes::SystemTypesystem));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::Type));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::StringType));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::IntType));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::DoubleType));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::BoolType));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::EnumType));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::StructType));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::ArrayType));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::UnknownType));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::Constant));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::Attribute));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::Typesystem));
+ ASSERT_FALSE(enumType->composedOf(&RttiTypes::SystemTypesystem));
}
TEST(EnumType, creation)
@@ -476,22 +476,22 @@ TEST(StructType, rtti)
{
Manager mgr;
Rooted<StructType> structType = createStructType(mgr, logger);
- ASSERT_TRUE(structType->isa(RttiTypes::StructType));
+ ASSERT_TRUE(structType->isa(&RttiTypes::StructType));
ASSERT_TRUE(structType->isa(typeOf<Type>()));
ASSERT_TRUE(structType->isa(typeOf<Node>()));
- ASSERT_FALSE(structType->composedOf(RttiTypes::Type));
- ASSERT_FALSE(structType->composedOf(RttiTypes::StringType));
- ASSERT_FALSE(structType->composedOf(RttiTypes::IntType));
- ASSERT_FALSE(structType->composedOf(RttiTypes::DoubleType));
- ASSERT_FALSE(structType->composedOf(RttiTypes::BoolType));
- ASSERT_FALSE(structType->composedOf(RttiTypes::EnumType));
- ASSERT_FALSE(structType->composedOf(RttiTypes::StructType));
- ASSERT_FALSE(structType->composedOf(RttiTypes::ArrayType));
- ASSERT_FALSE(structType->composedOf(RttiTypes::UnknownType));
- ASSERT_FALSE(structType->composedOf(RttiTypes::Constant));
- ASSERT_TRUE(structType->composedOf(RttiTypes::Attribute));
- ASSERT_FALSE(structType->composedOf(RttiTypes::Typesystem));
- ASSERT_FALSE(structType->composedOf(RttiTypes::SystemTypesystem));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::Type));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::StringType));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::IntType));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::DoubleType));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::BoolType));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::EnumType));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::StructType));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::ArrayType));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::UnknownType));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::Constant));
+ ASSERT_TRUE(structType->composedOf(&RttiTypes::Attribute));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::Typesystem));
+ ASSERT_FALSE(structType->composedOf(&RttiTypes::SystemTypesystem));
}
TEST(StructType, creation)
@@ -789,22 +789,22 @@ TEST(ArrayType, rtti)
Manager mgr;
Rooted<StringType> stringType{new StringType(mgr, nullptr)};
Rooted<ArrayType> arrayType{new ArrayType(stringType)};
- ASSERT_TRUE(arrayType->isa(RttiTypes::ArrayType));
+ ASSERT_TRUE(arrayType->isa(&RttiTypes::ArrayType));
ASSERT_TRUE(arrayType->isa(typeOf<Type>()));
ASSERT_TRUE(arrayType->isa(typeOf<Node>()));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::Type));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::StringType));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::IntType));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::DoubleType));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::BoolType));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::EnumType));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::StructType));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::ArrayType));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::UnknownType));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::Constant));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::Attribute));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::Typesystem));
- ASSERT_FALSE(arrayType->composedOf(RttiTypes::SystemTypesystem));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::Type));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::StringType));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::IntType));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::DoubleType));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::BoolType));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::EnumType));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::StructType));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::ArrayType));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::UnknownType));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::Constant));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::Attribute));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::Typesystem));
+ ASSERT_FALSE(arrayType->composedOf(&RttiTypes::SystemTypesystem));
}
TEST(ArrayType, creation)
@@ -910,22 +910,22 @@ TEST(UnknownType, rtti)
{
Manager mgr;
Rooted<UnknownType> unknownType{new UnknownType(mgr)};
- ASSERT_TRUE(unknownType->isa(RttiTypes::UnknownType));
+ ASSERT_TRUE(unknownType->isa(&RttiTypes::UnknownType));
ASSERT_TRUE(unknownType->isa(typeOf<Type>()));
ASSERT_TRUE(unknownType->isa(typeOf<Node>()));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::Type));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::StringType));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::IntType));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::DoubleType));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::BoolType));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::EnumType));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::StructType));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::ArrayType));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::UnknownType));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::Constant));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::Attribute));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::Typesystem));
- ASSERT_FALSE(unknownType->composedOf(RttiTypes::SystemTypesystem));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::Type));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::StringType));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::IntType));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::DoubleType));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::BoolType));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::EnumType));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::StructType));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::ArrayType));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::UnknownType));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::Constant));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::Attribute));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::Typesystem));
+ ASSERT_FALSE(unknownType->composedOf(&RttiTypes::SystemTypesystem));
}
TEST(UnknownType, creation)
@@ -956,19 +956,19 @@ TEST(Typesystem, rtti)
{
Manager mgr{1};
Rooted<Typesystem> typesystem{new Typesystem{mgr, "typesystem"}};
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::Type));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::StringType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::IntType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::DoubleType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::BoolType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::EnumType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::StructType));
- ASSERT_FALSE(typesystem->composedOf(RttiTypes::ArrayType));
- ASSERT_FALSE(typesystem->composedOf(RttiTypes::UnknownType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::Constant));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::Attribute));
- ASSERT_FALSE(typesystem->composedOf(RttiTypes::Typesystem));
- ASSERT_FALSE(typesystem->composedOf(RttiTypes::SystemTypesystem));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Type));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::StringType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::IntType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::DoubleType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::BoolType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::EnumType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::StructType));
+ ASSERT_FALSE(typesystem->composedOf(&RttiTypes::ArrayType));
+ ASSERT_FALSE(typesystem->composedOf(&RttiTypes::UnknownType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Constant));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Attribute));
+ ASSERT_FALSE(typesystem->composedOf(&RttiTypes::Typesystem));
+ ASSERT_FALSE(typesystem->composedOf(&RttiTypes::SystemTypesystem));
}
/* Class SystemTypesystem */
@@ -977,18 +977,18 @@ TEST(SystemTypesystem, rtti)
{
Manager mgr{1};
Rooted<SystemTypesystem> typesystem{new SystemTypesystem{mgr}};
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::Type));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::StringType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::IntType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::DoubleType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::BoolType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::EnumType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::StructType));
- ASSERT_FALSE(typesystem->composedOf(RttiTypes::ArrayType));
- ASSERT_FALSE(typesystem->composedOf(RttiTypes::UnknownType));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::Constant));
- ASSERT_TRUE(typesystem->composedOf(RttiTypes::Attribute));
- ASSERT_FALSE(typesystem->composedOf(RttiTypes::Typesystem));
- ASSERT_FALSE(typesystem->composedOf(RttiTypes::SystemTypesystem));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Type));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::StringType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::IntType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::DoubleType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::BoolType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::EnumType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::StructType));
+ ASSERT_FALSE(typesystem->composedOf(&RttiTypes::ArrayType));
+ ASSERT_FALSE(typesystem->composedOf(&RttiTypes::UnknownType));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Constant));
+ ASSERT_TRUE(typesystem->composedOf(&RttiTypes::Attribute));
+ ASSERT_FALSE(typesystem->composedOf(&RttiTypes::Typesystem));
+ ASSERT_FALSE(typesystem->composedOf(&RttiTypes::SystemTypesystem));
}
}
diff --git a/test/plugins/xml/XmlParserTest.cpp b/test/plugins/xml/XmlParserTest.cpp
index 4b5e1e4..af1ef56 100644
--- a/test/plugins/xml/XmlParserTest.cpp
+++ b/test/plugins/xml/XmlParserTest.cpp
@@ -120,7 +120,7 @@ static Rooted<StructuredClass> checkStructuredClass(
Handle<StructuredClass> superclass = nullptr, bool transparent = false,
bool root = false)
{
- auto res = domain->resolve(RttiTypes::StructuredClass, resolve);
+ auto res = domain->resolve(&RttiTypes::StructuredClass, resolve);
if (res.size() != 1) {
throw OusiaException("resolution error!");
}
@@ -146,7 +146,7 @@ static Rooted<AnnotationClass> checkAnnotationClass(
const std::string &resolve, const std::string &name, Handle<Domain> domain,
Handle<StructType> attributesDescriptor = nullptr)
{
- auto res = domain->resolve(RttiTypes::AnnotationClass, resolve);
+ auto res = domain->resolve(&RttiTypes::AnnotationClass, resolve);
if (res.size() != 1) {
throw OusiaException("resolution error!");
}
@@ -183,7 +183,7 @@ static void checkFieldDescriptor(
FieldDescriptor::FieldType type = FieldDescriptor::FieldType::TREE,
Handle<Type> primitiveType = nullptr, bool optional = false)
{
- auto res = desc->resolve(RttiTypes::FieldDescriptor, name);
+ auto res = desc->resolve(&RttiTypes::FieldDescriptor, name);
ASSERT_EQ(1, res.size());
checkFieldDescriptor(res[0].node, name, parent, children, type,
primitiveType, optional);
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-30 22:42:38 +0000