From 90b2e9507e9d720452792b863b422221fe96d948 Mon Sep 17 00:00:00 2001 From: Andreas Stöckel Date: Thu, 29 Jan 2015 22:52:29 +0100 Subject: Unified signature of resolve functions, passing the "owner" to the callback functions in ParserScope::resolve --- test/core/model/DomainTest.cpp | 26 +++++++------- test/core/model/NodeTest.cpp | 62 ++++++++++++++++----------------- test/core/model/TestAdvanced.hpp | 2 +- test/core/model/TestDocumentBuilder.hpp | 2 +- 4 files changed, 46 insertions(+), 46 deletions(-) (limited to 'test') diff --git a/test/core/model/DomainTest.cpp b/test/core/model/DomainTest.cpp index 8bf1a47..767ac0c 100644 --- a/test/core/model/DomainTest.cpp +++ b/test/core/model/DomainTest.cpp @@ -50,41 +50,41 @@ TEST(Domain, testDomainResolving) std::vector res; // There is one domain called "book" - res = domain->resolve("book", typeOf()); + res = domain->resolve(RttiTypes::Domain, "book"); ASSERT_EQ(1U, res.size()); - assert_path(res[0], typeOf(), {"book"}); + assert_path(res[0], RttiTypes::Domain, {"book"}); // There is one domain called "book" - res = domain->resolve("book", typeOf()); + res = domain->resolve(RttiTypes::StructuredClass, "book"); ASSERT_EQ(1U, res.size()); - assert_path(res[0], typeOf(), {"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(std::vector{"book", "book"}, - typeOf()); + res = domain->resolve(RttiTypes::Domain, + std::vector{"book", "book"}); ASSERT_EQ(0U, res.size()); - res = domain->resolve(std::vector{"book", "book"}, - typeOf()); + res = domain->resolve(RttiTypes::StructuredClass, + std::vector{"book", "book"}); ASSERT_EQ(1U, res.size()); // If we ask for "section" the result should be unique as well. - res = domain->resolve("section", typeOf()); + res = domain->resolve(RttiTypes::StructuredClass, "section"); ASSERT_EQ(1U, res.size()); - assert_path(res[0], typeOf(), {"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("paragraph", typeOf()); + res = domain->resolve(RttiTypes::StructuredClass, "paragraph"); ASSERT_EQ(1U, res.size()); - assert_path(res[0], typeOf(), {"book", "paragraph"}); + assert_path(res[0], RttiTypes::StructuredClass, {"book", "paragraph"}); } Rooted getClass(const std::string name, Handle dom) { std::vector res = - dom->resolve(name, RttiTypes::StructuredClass); + dom->resolve(RttiTypes::StructuredClass, name); return res[0].node.cast(); } diff --git a/test/core/model/NodeTest.cpp b/test/core/model/NodeTest.cpp index a9a699d..d9ca5bb 100644 --- a/test/core/model/NodeTest.cpp +++ b/test/core/model/NodeTest.cpp @@ -61,8 +61,8 @@ public: namespace RttiTypes { const Rtti TestNode = RttiBuilder("TestNode") - .parent(&RttiTypes::Node) - .composedOf(&TestNode); + .parent(&RttiTypes::Node) + .composedOf(&TestNode); } TEST(Node, isRoot) @@ -85,18 +85,18 @@ TEST(Node, resolveCompositaSimple) child1->addCompositum(new TestNode(mgr, "child11")); std::vector res; - res = root->resolve(std::vector{"root", "child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"root", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); - res = root->resolve(std::vector{"child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); res = - root->resolve(std::vector{"child11"}, RttiTypes::TestNode); + root->resolve(RttiTypes::TestNode, std::vector{"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 res; - res = root->resolve(std::vector{"root", "child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"root", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); - res = root->resolve(std::vector{"child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); res = - root->resolve(std::vector{"child11"}, RttiTypes::TestNode); + root->resolve(RttiTypes::TestNode, std::vector{"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 res; - res = root->resolve(std::vector{"child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"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(std::vector{"child11"}, RttiTypes::TestNode); + root->resolve(RttiTypes::TestNode, std::vector{"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 res; - res = root->resolve(std::vector{"a", "child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"a", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); - res = root->resolve(std::vector{"b", "child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"b", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child112 == res[0].node); - res = root->resolve(std::vector{"child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"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(std::vector{"child11"}, RttiTypes::TestNode); + root->resolve(RttiTypes::TestNode, std::vector{"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(std::vector{"child1"}, RttiTypes::TestNode); + root->resolve(RttiTypes::TestNode, std::vector{"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 child13 = root->addCompositum(new TestNode(mgr, "child1")); std::vector res; - res = root->resolve(std::vector{"a", "child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"a", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child11 == res[0].node); - res = root->resolve(std::vector{"b", "child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"b", "child1", "child11"}); ASSERT_EQ(1U, res.size()); ASSERT_TRUE(child112 == res[0].node); - res = root->resolve(std::vector{"child1", "child11"}, - RttiTypes::TestNode); + res = root->resolve(RttiTypes::TestNode, + std::vector{"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(std::vector{"child11"}, RttiTypes::TestNode); + root->resolve(RttiTypes::TestNode, std::vector{"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(std::vector{"child1"}, RttiTypes::TestNode); + root->resolve(RttiTypes::TestNode, std::vector{"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 d90f917..e3744b8 100644 --- a/test/core/model/TestAdvanced.hpp +++ b/test/core/model/TestAdvanced.hpp @@ -32,7 +32,7 @@ static Rooted resolveDescriptor(Handle domain, { // use the actual resolve method. std::vector resolved = - domain->resolve(className, typeOf()); + domain->resolve(RttiTypes::StructuredClass, className); // take the first valid result. for (auto &r : resolved) { return r.node.cast(); diff --git a/test/core/model/TestDocumentBuilder.hpp b/test/core/model/TestDocumentBuilder.hpp index 149b88e..71b353d 100644 --- a/test/core/model/TestDocumentBuilder.hpp +++ b/test/core/model/TestDocumentBuilder.hpp @@ -48,7 +48,7 @@ static Rooted resolveDescriptor(Handle doc, const Rtti &type) { // use the actual resolve method. - std::vector resolved = doc->resolve(path, type); + std::vector resolved = doc->resolve(type, path); // if we don't find anything, log an error if (resolved.size() == 0) { logger.error(std::string("Could not resolve ") + getPathString(path)); -- cgit v1.2.3