Some (slight) changes to existing structures and first attempts on a test to construct a test comain and a test document out of thin air. I am, indeed, an alchemist.

3 files changed, 131 insertions, 12 deletions

diff --git a/test/core/managed/ManagedContainerTest.cpp b/test/core/managed/ManagedContainerTest.cpp
index c34541a..7ff819f 100644
--- a/test/core/managed/ManagedContainerTest.cpp
+++ b/test/core/managed/ManagedContainerTest.cpp
@@ -38,7 +38,7 @@ TEST(ManagedVector, managedVector)
 	{
 		Rooted<Managed> root{new Managed{mgr}};
 
-		std::vector<TestManaged*> elems;
+		std::vector<TestManaged *> elems;
 		for (int i = 0; i < nElem; i++) {
 			elems.push_back(new TestManaged{mgr, a[i]});
 		}
@@ -49,7 +49,8 @@ TEST(ManagedVector, managedVector)
 
 		ManagedVector<TestManaged> v(root, elems.begin(), elems.end());
 
-		// Remove the last element from the list. It should be garbage collected.
+		// Remove the last element from the list. It should be garbage
+		// collected.
 		v.pop_back();
 		ASSERT_FALSE(a[nElem - 1]);
 
@@ -85,7 +86,6 @@ TEST(ManagedVector, managedVector)
 	}
 }
 
-
 TEST(ManagedVector, moveAssignment)
 {
 	constexpr int nElem = 16;
@@ -220,16 +220,39 @@ TEST(ManagedVector, moveWithNewOwner)
 	}
 }
 
-class TestManagedWithContainer : public Managed {
+TEST(ManagedVector, accessOperator)
+{
+	Manager mgr{1};
+	Rooted<Managed> root{new Managed{mgr}};
+	ManagedVector<Managed> instance{root};
+	Rooted<Managed> elem{new Managed{mgr}};
+	instance.push_back(elem);
+
+	ASSERT_EQ(elem, instance[0]);
+
+	// Test out of bounds.
+	bool caught = false;
+	try {
+		instance[1];
+	}
+	catch (std::out_of_range ex) {
+		caught = true;
+	}
+	ASSERT_TRUE(caught);
+
+	instance.push_back(elem);
+	ASSERT_EQ(elem, instance[1]);
+}
 
+class TestManagedWithContainer : public Managed {
 public:
 	ManagedVector<TestManaged> elems;
 
-	TestManagedWithContainer(Manager &mgr) : Managed(mgr), elems(this) {};
-
+	TestManagedWithContainer(Manager &mgr) : Managed(mgr), elems(this){};
 };
 
-TEST(ManagedVector, embedded) {
+TEST(ManagedVector, embedded)
+{
 	// Note: This test depends on the correct deletion order -- otherwise
 	// valgrind shows an error
 	bool a;
@@ -248,7 +271,6 @@ TEST(ManagedVector, embedded) {
 	ASSERT_FALSE(a);
 }
 
-
 TEST(ManagedMap, managedMap)
 {
 	// TODO: This test is highly incomplete
@@ -260,7 +282,7 @@ TEST(ManagedMap, managedMap)
 	{
 		Rooted<Managed> root{new Managed{mgr}};
 
-		std::map<int, TestManaged*> elems;
+		std::map<int, TestManaged *> elems;
 		for (int i = 0; i < nElem; i++) {
 			elems.insert(std::make_pair(i, new TestManaged{mgr, a[i]}));
 		}
@@ -298,6 +320,5 @@ TEST(ManagedMap, managedMap)
 		ASSERT_FALSE(v);
 	}
 }
-
 }
 
diff --git a/test/core/model/DocumentTest.cpp b/test/core/model/DocumentTest.cpp
index 36e7c02..dd883a4 100644
--- a/test/core/model/DocumentTest.cpp
+++ b/test/core/model/DocumentTest.cpp
@@ -20,12 +20,20 @@
 
 #include <core/model/Document.hpp>
 
+#include "ModelTestUtils.hpp"
+
 namespace ousia {
 namespace model {
+
+
 TEST(Document, testDocumentConstruction)
 {
-	// Start by constructing the domain.
-	//TODO: IMPLEMENT
+	// Construct Manager
+	Manager mgr{1};
+	// Get the domain.
+	Rooted<Domain> domain = constructBookDomain(mgr);
+
+	// TODO: IMPLEMENT
 	ASSERT_TRUE(true);
 }
 }
diff --git a/test/core/model/ModelTestUtils.hpp b/test/core/model/ModelTestUtils.hpp
new file mode 100644
index 0000000..665e351
--- /dev/null
+++ b/test/core/model/ModelTestUtils.hpp
@@ -0,0 +1,90 @@
+/*
+    Ousía
+    Copyright (C) 2014, 2015  Benjamin Paaßen, Andreas Stöckel
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _MODEL_TEST_UTILS_HPP_
+#define _MODEL_TEST_UTILS_HPP_
+
+#include <core/model/Domain.hpp>
+#include <core/model/Typesystem.hpp>
+
+namespace ousia {
+namespace model {
+
+/**
+ * This constructs a somewhat trivial system of standard types.
+ *
+ * Currently contained: string
+ */
+static Rooted<Typesystem> constructTypeSystem(Manager &mgr)
+{
+	Rooted<Typesystem> sys{new Typesystem(mgr, "std")};
+	Rooted<StringType> string{new StringType(mgr, sys)};
+	sys->addType(string);
+
+	return sys;
+}
+
+/**
+ * This constructs the "book" domain for test purposes. The structure of the
+ * domain is fairly and can be seen from the construction itself.
+ */
+static Rooted<Domain> constructBookDomain(Manager &mgr)
+{
+	// Start with the Domain itself.
+	Rooted<Domain> domain{new Domain(mgr, "book")};
+	// The standard type system.
+	domain->getTypesystems().push_back(constructTypeSystem(mgr));
+	// Set up the cardinalities we'll need.
+	Cardinality single;
+	single.merge({1});
+	Cardinality any;
+	any.merge(Range<size_t>::typeRangeFrom(0));
+
+	// Set up the "book" node.
+	Rooted<StructuredClass> book{
+	    new StructuredClass(mgr, "book", domain, single)};
+	domain->getRootStructures().push_back(book);
+	// The structure field of it.
+	Rooted<FieldDescriptor> book_field{new FieldDescriptor(mgr, book)};
+	book->getFieldDescriptors().push_back(book_field);
+
+	// From there on the "section".
+	Rooted<StructuredClass> section{
+	    new StructuredClass(mgr, "section", domain, any)};
+	book_field->getChildren().push_back(section);
+	// And the field of it.
+	Rooted<FieldDescriptor> section_field{new FieldDescriptor(mgr, section)};
+	section->getFieldDescriptors().push_back(section_field);
+
+	// We also add the "paragraph", which is transparent.
+	Rooted<StructuredClass> paragraph{new StructuredClass(
+	    mgr, "paragraph", domain, any, {nullptr}, {nullptr}, true)};
+	section_field->getChildren().push_back(paragraph);
+	book_field->getChildren().push_back(paragraph);
+	// ... and has a primitive field.
+	Rooted<FieldDescriptor> text{new FieldDescriptor(
+	    mgr, paragraph, domain->getTypesystems()[0]->getTypes()[0], "text",
+	    false)};
+
+	return domain;
+}
+}
+}
+
+#endif /* _TEST_MANAGED_H_ */
+