From b7f67dc04857e8d303f94cbfa246a10bcfec4817 Mon Sep 17 00:00:00 2001 From: Andreas Stöckel Date: Fri, 9 Jan 2015 14:55:10 +0100 Subject: Added new unit tests for the Node.resolve function and fixed the behaviour for not following references if a compositum was found --- test/core/model/NodeTest.cpp | 173 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 159 insertions(+), 14 deletions(-) (limited to 'test/core/model/NodeTest.cpp') diff --git a/test/core/model/NodeTest.cpp b/test/core/model/NodeTest.cpp index 334a311..880ce33 100644 --- a/test/core/model/NodeTest.cpp +++ b/test/core/model/NodeTest.cpp @@ -24,23 +24,35 @@ namespace ousia { class TestNode : public Node { -private: - std::vector> children; - protected: void continueResolve(ResolutionState &state) override { - continueResolveComposita(children, state); + continueResolveComposita(composita, composita.getIndex(), state); + continueResolveReferences(references, state); } public: - using Node::Node; + NodeVector composita; + NodeVector references; - Rooted addChild(Handle node) + TestNode(Manager &mgr, Handle parent = nullptr) + : Node(mgr, parent), composita(this), references(this) { - Owned nd = acquire(node); - children.push_back(nd); - return nd; + } + + TestNode(Manager &mgr, std::string name, Handle parent = nullptr) + : Node(mgr, name, parent), composita(this), references(this) + { + } + + Rooted addCompositum(Handle n) { + composita.push_back(n); + return n; + } + + Rooted addReference(Handle n) { + references.push_back(n); + return n; } }; @@ -51,7 +63,7 @@ const Rtti TestNode = TEST(Node, isRoot) { - Manager mgr; + Manager mgr{1}; Rooted n1{new TestNode(mgr)}; Rooted n2{new TestNode(mgr)}; Rooted n3{new TestNode(mgr, n2)}; @@ -65,12 +77,37 @@ TEST(Node, isRoot) ASSERT_FALSE(n3->isRoot()); } -TEST(Node, simpleResolve) +TEST(Node, resolveCompositaSimple) +{ + Manager mgr{1}; + Rooted root{new TestNode(mgr, "root")}; + Rooted child1 = root->addCompositum(new TestNode(mgr, "child1")); + Rooted child11 = child1->addCompositum(new TestNode(mgr, "child11")); + + std::vector res; + res = root->resolve(std::vector{"root", "child1", "child11"}, + RttiTypes::TestNode); + ASSERT_EQ(1U, res.size()); + ASSERT_TRUE(child11 == res[0].node); + + res = root->resolve(std::vector{"child1", "child11"}, + RttiTypes::TestNode); + ASSERT_EQ(1U, res.size()); + ASSERT_TRUE(child11 == res[0].node); + + res = + root->resolve(std::vector{"child11"}, RttiTypes::TestNode); + ASSERT_EQ(1U, res.size()); + ASSERT_TRUE(child11 == res[0].node); +} + +TEST(Node, resolveCompositaDouble) { - Manager mgr; + Manager mgr{1}; Rooted root{new TestNode(mgr, "root")}; - Rooted child1 = root->addChild(new TestNode(mgr, "child1")); - Rooted child11 = child1->addChild(new TestNode(mgr, "child11")); + Rooted root2 = root->addCompositum(new TestNode(mgr, "root")); + Rooted child1 = root2->addCompositum(new TestNode(mgr, "child1")); + Rooted child11 = child1->addCompositum(new TestNode(mgr, "child11")); std::vector res; res = root->resolve(std::vector{"root", "child1", "child11"}, @@ -89,4 +126,112 @@ TEST(Node, simpleResolve) ASSERT_TRUE(child11 == res[0].node); } +TEST(Node, resolveAmbigousComposita) +{ + Manager mgr{1}; + Rooted root{new TestNode(mgr, "root")}; + Rooted a = root->addCompositum(new TestNode(mgr, "a")); + Rooted b = root->addCompositum(new TestNode(mgr, "b")); + Rooted child1 = a->addCompositum(new TestNode(mgr, "child1")); + Rooted child11 = child1->addCompositum(new TestNode(mgr, "child11")); + Rooted child12 = b->addCompositum(new TestNode(mgr, "child1")); + Rooted child112 = child12->addCompositum(new TestNode(mgr, "child11")); + + std::vector res; + res = root->resolve(std::vector{"child1", "child11"}, + RttiTypes::TestNode); + 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); + 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); +} + +TEST(Node, resolveReferences) +{ + Manager mgr{1}; + Rooted root{new TestNode(mgr, "root")}; + Rooted a = root->addReference(new TestNode(mgr, "a")); + Rooted b = root->addReference(new TestNode(mgr, "b")); + Rooted child1 = a->addCompositum(new TestNode(mgr, "child1")); + Rooted child11 = child1->addCompositum(new TestNode(mgr, "child11")); + Rooted child12 = b->addCompositum(new TestNode(mgr, "child1")); + Rooted child112 = child12->addCompositum(new TestNode(mgr, "child11")); + + std::vector res; + res = root->resolve(std::vector{"a", "child1", "child11"}, + RttiTypes::TestNode); + ASSERT_EQ(1U, res.size()); + ASSERT_TRUE(child11 == res[0].node); + + res = root->resolve(std::vector{"b", "child1", "child11"}, + RttiTypes::TestNode); + ASSERT_EQ(1U, res.size()); + ASSERT_TRUE(child112 == res[0].node); + + res = root->resolve(std::vector{"child1", "child11"}, + RttiTypes::TestNode); + 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); + 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); + 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); +} + +TEST(Node, resolveReferencesAndComposita) +{ + Manager mgr{1}; + Rooted root{new TestNode(mgr, "root")}; + Rooted a = root->addReference(new TestNode(mgr, "a")); + Rooted b = root->addReference(new TestNode(mgr, "b")); + Rooted child1 = a->addCompositum(new TestNode(mgr, "child1")); + Rooted child11 = child1->addCompositum(new TestNode(mgr, "child11")); + Rooted child12 = b->addCompositum(new TestNode(mgr, "child1")); + Rooted child112 = child12->addCompositum(new TestNode(mgr, "child11")); + Rooted child13 = root->addCompositum(new TestNode(mgr, "child1")); + + std::vector res; + res = root->resolve(std::vector{"a", "child1", "child11"}, + RttiTypes::TestNode); + ASSERT_EQ(1U, res.size()); + ASSERT_TRUE(child11 == res[0].node); + + res = root->resolve(std::vector{"b", "child1", "child11"}, + RttiTypes::TestNode); + ASSERT_EQ(1U, res.size()); + ASSERT_TRUE(child112 == res[0].node); + + res = root->resolve(std::vector{"child1", "child11"}, + RttiTypes::TestNode); + 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); + 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); + ASSERT_EQ(1U, res.size()); + ASSERT_TRUE(child13 == res[0].node); +} + } -- cgit v1.2.3