Merge branch 'master' of somweyr.de:ousia

1 files changed, 159 insertions, 14 deletions

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<Owned<Node>> children;
-
 protected:
 	void continueResolve(ResolutionState &state) override
 	{
-		continueResolveComposita(children, state);
+		continueResolveComposita(composita, composita.getIndex(), state);
+		continueResolveReferences(references, state);
 	}
 
 public:
-	using Node::Node;
+	NodeVector<TestNode> composita;
+	NodeVector<TestNode> references;
 
-	Rooted<TestNode> addChild(Handle<TestNode> node)
+	TestNode(Manager &mgr, Handle<Node> parent = nullptr)
+	    : Node(mgr, parent), composita(this), references(this)
 	{
-		Owned<TestNode> nd = acquire(node);
-		children.push_back(nd);
-		return nd;
+	}
+
+	TestNode(Manager &mgr, std::string name, Handle<Node> parent = nullptr)
+	    : Node(mgr, name, parent), composita(this), references(this)
+	{
+	}
+
+	Rooted<TestNode> addCompositum(Handle<TestNode> n) {
+		composita.push_back(n);
+		return n;
+	}
+
+	Rooted<TestNode> addReference(Handle<TestNode> n) {
+		references.push_back(n);
+		return n;
 	}
 };
 
@@ -51,7 +63,7 @@ const Rtti<ousia::TestNode> TestNode =
 
 TEST(Node, isRoot)
 {
-	Manager mgr;
+	Manager mgr{1};
 	Rooted<TestNode> n1{new TestNode(mgr)};
 	Rooted<TestNode> n2{new TestNode(mgr)};
 	Rooted<TestNode> 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<TestNode> root{new TestNode(mgr, "root")};
+	Rooted<TestNode> child1 = root->addCompositum(new TestNode(mgr, "child1"));
+	Rooted<TestNode> child11 = child1->addCompositum(new TestNode(mgr, "child11"));
+
+	std::vector<ResolutionResult> res;
+	res = root->resolve(std::vector<std::string>{"root", "child1", "child11"},
+	                    RttiTypes::TestNode);
+	ASSERT_EQ(1U, res.size());
+	ASSERT_TRUE(child11 == res[0].node);
+
+	res = root->resolve(std::vector<std::string>{"child1", "child11"},
+	                    RttiTypes::TestNode);
+	ASSERT_EQ(1U, res.size());
+	ASSERT_TRUE(child11 == res[0].node);
+
+	res =
+	    root->resolve(std::vector<std::string>{"child11"}, RttiTypes::TestNode);
+	ASSERT_EQ(1U, res.size());
+	ASSERT_TRUE(child11 == res[0].node);
+}
+
+TEST(Node, resolveCompositaDouble)
 {
-	Manager mgr;
+	Manager mgr{1};
 	Rooted<TestNode> root{new TestNode(mgr, "root")};
-	Rooted<TestNode> child1 = root->addChild(new TestNode(mgr, "child1"));
-	Rooted<TestNode> child11 = child1->addChild(new TestNode(mgr, "child11"));
+	Rooted<TestNode> root2 = root->addCompositum(new TestNode(mgr, "root"));
+	Rooted<TestNode> child1 = root2->addCompositum(new TestNode(mgr, "child1"));
+	Rooted<TestNode> child11 = child1->addCompositum(new TestNode(mgr, "child11"));
 
 	std::vector<ResolutionResult> res;
 	res = root->resolve(std::vector<std::string>{"root", "child1", "child11"},
@@ -89,4 +126,112 @@ TEST(Node, simpleResolve)
 	ASSERT_TRUE(child11 == res[0].node);
 }
 
+TEST(Node, resolveAmbigousComposita)
+{
+	Manager mgr{1};
+	Rooted<TestNode> root{new TestNode(mgr, "root")};
+	Rooted<TestNode> a = root->addCompositum(new TestNode(mgr, "a"));
+	Rooted<TestNode> b = root->addCompositum(new TestNode(mgr, "b"));
+	Rooted<TestNode> child1 = a->addCompositum(new TestNode(mgr, "child1"));
+	Rooted<TestNode> child11 = child1->addCompositum(new TestNode(mgr, "child11"));
+	Rooted<TestNode> child12 = b->addCompositum(new TestNode(mgr, "child1"));
+	Rooted<TestNode> child112 = child12->addCompositum(new TestNode(mgr, "child11"));
+
+	std::vector<ResolutionResult> res;
+	res = root->resolve(std::vector<std::string>{"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<std::string>{"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<TestNode> root{new TestNode(mgr, "root")};
+	Rooted<TestNode> a = root->addReference(new TestNode(mgr, "a"));
+	Rooted<TestNode> b = root->addReference(new TestNode(mgr, "b"));
+	Rooted<TestNode> child1 = a->addCompositum(new TestNode(mgr, "child1"));
+	Rooted<TestNode> child11 = child1->addCompositum(new TestNode(mgr, "child11"));
+	Rooted<TestNode> child12 = b->addCompositum(new TestNode(mgr, "child1"));
+	Rooted<TestNode> child112 = child12->addCompositum(new TestNode(mgr, "child11"));
+
+	std::vector<ResolutionResult> res;
+	res = root->resolve(std::vector<std::string>{"a", "child1", "child11"},
+	                    RttiTypes::TestNode);
+	ASSERT_EQ(1U, res.size());
+	ASSERT_TRUE(child11 == res[0].node);
+
+	res = root->resolve(std::vector<std::string>{"b", "child1", "child11"},
+	                    RttiTypes::TestNode);
+	ASSERT_EQ(1U, res.size());
+	ASSERT_TRUE(child112 == res[0].node);
+
+	res = root->resolve(std::vector<std::string>{"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<std::string>{"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<std::string>{"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<TestNode> root{new TestNode(mgr, "root")};
+	Rooted<TestNode> a = root->addReference(new TestNode(mgr, "a"));
+	Rooted<TestNode> b = root->addReference(new TestNode(mgr, "b"));
+	Rooted<TestNode> child1 = a->addCompositum(new TestNode(mgr, "child1"));
+	Rooted<TestNode> child11 = child1->addCompositum(new TestNode(mgr, "child11"));
+	Rooted<TestNode> child12 = b->addCompositum(new TestNode(mgr, "child1"));
+	Rooted<TestNode> child112 = child12->addCompositum(new TestNode(mgr, "child11"));
+	Rooted<TestNode> child13 = root->addCompositum(new TestNode(mgr, "child1"));
+
+	std::vector<ResolutionResult> res;
+	res = root->resolve(std::vector<std::string>{"a", "child1", "child11"},
+	                    RttiTypes::TestNode);
+	ASSERT_EQ(1U, res.size());
+	ASSERT_TRUE(child11 == res[0].node);
+
+	res = root->resolve(std::vector<std::string>{"b", "child1", "child11"},
+	                    RttiTypes::TestNode);
+	ASSERT_EQ(1U, res.size());
+	ASSERT_TRUE(child112 == res[0].node);
+
+	res = root->resolve(std::vector<std::string>{"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<std::string>{"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<std::string>{"child1"}, RttiTypes::TestNode);
+	ASSERT_EQ(1U, res.size());
+	ASSERT_TRUE(child13 == res[0].node);
+}
+
 }