Refactored building convenience methods to TestDocumentBuilder, added error logging and changed TestDocument and TestAdvanced as well as all users of those files accordingly.

5 files changed, 366 insertions, 65 deletions

diff --git a/test/core/model/DocumentTest.cpp b/test/core/model/DocumentTest.cpp
index c86b285..2d53dcd 100644
--- a/test/core/model/DocumentTest.cpp
+++ b/test/core/model/DocumentTest.cpp
@@ -18,6 +18,8 @@
 
 #include <gtest/gtest.h>
 
+#include <iostream>
+
 #include <core/model/Document.hpp>
 #include <core/model/Domain.hpp>
 
@@ -30,13 +32,13 @@ namespace model {
 TEST(Document, testDocumentConstruction)
 {
 	// Construct Manager
-	Logger logger;
+	TerminalLogger logger {std::cerr, true};
 	Manager mgr{1};
 	Rooted<SystemTypesystem> sys{new SystemTypesystem(mgr)};
 	// Get the domain.
 	Rooted<Domain> domain = constructBookDomain(mgr, sys, logger);
 	// Construct the document.
-	Rooted<Document> doc = constructBookDocument(mgr, domain);
+	Rooted<Document> doc = constructBookDocument(mgr, logger, domain);
 
 	// Check the document content.
 	ASSERT_FALSE(doc.isNull());
diff --git a/test/core/model/TestAdvanced.hpp b/test/core/model/TestAdvanced.hpp
index 59d79ad..a1510e7 100644
--- a/test/core/model/TestAdvanced.hpp
+++ b/test/core/model/TestAdvanced.hpp
@@ -16,13 +16,15 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef _MODEL_TEST_DOCUMENT_HPP_
-#define _MODEL_TEST_DOCUMENT_HPP_
+#ifndef _MODEL_TEST_ADVANCED_HPP_
+#define _MODEL_TEST_ADVANCED_HPP_
 
 #include <core/model/Document.hpp>
 #include <core/model/Domain.hpp>
 #include <core/model/Typesystem.hpp>
 
+#include "TestDocumentBuilder.hpp"
+
 namespace ousia {
 namespace model {
 
@@ -30,7 +32,8 @@ static Rooted<StructuredClass> resolveDescriptor(Handle<Domain> domain,
                                                  const std::string &className)
 {
 	// use the actual resolve method.
-	std::vector<ResolutionResult> resolved = domain->resolve(className, typeOf<StructuredClass>());
+	std::vector<ResolutionResult> resolved =
+	    domain->resolve(className, typeOf<StructuredClass>());
 	// take the first valid result.
 	for (auto &r : resolved) {
 		return r.node.cast<StructuredClass>();
@@ -126,20 +129,19 @@ static Rooted<Domain> constructEmphasisDomain(Manager &mgr,
 	return domain;
 }
 
-static bool addText(Handle<StructuredEntity> parent,
-                    std::vector<Handle<Domain>> &doms,
-                    const std::string &content)
+static bool addText(Logger &logger, Handle<Document> doc,
+                    Handle<StructuredEntity> parent, const std::string &content)
 {
-	// Add its text.
+	// Add the text.
 	Rooted<StructuredEntity> text =
-	    StructuredEntity::buildEntity(parent, doms, "text");
+	    buildStructuredEntity(doc, logger, parent, {"text"});
 	if (text.isNull()) {
 		return false;
 	}
-	// And its primitive content
+	// And the primitive content
 	Variant content_var{content.c_str()};
 	Rooted<DocumentPrimitive> primitive =
-	    DocumentPrimitive::buildEntity(text, content_var, "content");
+	    buildPrimitiveEntity(logger, text, content_var, "content");
 	if (primitive.isNull()) {
 		return false;
 	}
@@ -147,18 +149,17 @@ static bool addText(Handle<StructuredEntity> parent,
 	return true;
 }
 
-static bool addHeading(Handle<StructuredEntity> parent,
-                       std::vector<Handle<Domain>> &doms,
-                       const std::string &text)
+static bool addHeading(Logger &logger, Handle<Document> doc,
+                       Handle<StructuredEntity> parent, const std::string &text)
 {
 	// Add the heading.
-	Rooted<StructuredEntity> heading = StructuredEntity::buildEntity(
-	    parent, doms, "heading", "heading", {}, "");
+	Rooted<StructuredEntity> heading = buildStructuredEntity(
+	    doc, logger, parent, {"heading"}, "heading", {}, "");
 	if (heading.isNull()) {
 		return false;
 	}
 	// Add its text.
-	if (!addText(heading, doms, text)) {
+	if (!addText(logger, doc, heading, text)) {
 		return false;
 	}
 	return true;
@@ -167,25 +168,25 @@ static bool addHeading(Handle<StructuredEntity> parent,
 static int annoIdx = 1;
 
 // Only works for non-overlapping annotations!
-static bool addAnnotation(Handle<Document> doc, Handle<StructuredEntity> parent,
-                          std::vector<Handle<Domain>> &doms,
+static bool addAnnotation(Logger &logger, Handle<Document> doc,
+                          Handle<StructuredEntity> parent,
                           const std::string &text, const std::string &annoClass)
 {
 	Rooted<AnnotationEntity::Anchor> start =
-	    AnnotationEntity::buildAnchor(parent, std::to_string(annoIdx++));
+	    buildAnchor(logger, parent, std::to_string(annoIdx++));
 	if (start.isNull()) {
 		return false;
 	}
-	if (!addText(parent, doms, text)) {
+	if (!addText(logger, doc, parent, text)) {
 		return false;
 	}
 	Rooted<AnnotationEntity::Anchor> end =
-	    AnnotationEntity::buildAnchor(parent, std::to_string(annoIdx++));
+	    buildAnchor(logger, parent, std::to_string(annoIdx++));
 	if (end.isNull()) {
 		return false;
 	}
 	Rooted<AnnotationEntity> anno =
-	    AnnotationEntity::buildEntity(doc, doms, annoClass, start, end);
+	    buildAnnotationEntity(doc, logger, {annoClass}, start, end);
 	if (anno.isNull()) {
 		return false;
 	}
@@ -197,34 +198,34 @@ static bool addAnnotation(Handle<Document> doc, Handle<StructuredEntity> parent,
  * domain but also headings, emphasis and lists.
  * TODO: insert emphasis and lists.
  */
-static Rooted<Document> constructAdvancedDocument(Manager &mgr,
+static Rooted<Document> constructAdvancedDocument(Manager &mgr, Logger &logger,
                                                   Handle<Domain> bookDom,
                                                   Handle<Domain> headingDom,
-                                                  Handle<Domain> listDom)
+                                                  Handle<Domain> listDom,
+                                                  Handle<Domain> emphasisDom)
 {
-	std::vector<Handle<Domain>> doms{bookDom, headingDom, listDom};
-
 	// Start with the (empty) document.
 	Rooted<Document> doc{new Document(mgr, "kant_was_ist_aufklaerung.oxd")};
+	doc->addDomains({bookDom, headingDom, listDom, emphasisDom});
 
 	// Add the root.
 	Rooted<StructuredEntity> book =
-	    StructuredEntity::buildRootEntity(doc, doms, "book");
+	    buildRootStructuredEntity(doc, logger, {"book"});
 	if (book.isNull()) {
 		return {nullptr};
 	}
 
 	// Add the heading.
 	{
-		Rooted<StructuredEntity> heading = StructuredEntity::buildEntity(
-		    book, doms, "heading", "heading", {}, "");
+		Rooted<StructuredEntity> heading = buildStructuredEntity(
+		    doc, logger, book, {"heading"}, "heading", {}, "");
 		if (heading.isNull()) {
 			return {nullptr};
 		}
-		if (!addText(heading, doms, "Beantwortung der Frage: ")) {
+		if (!addText(logger, doc, heading, "Beantwortung der Frage: ")) {
 			return {nullptr};
 		}
-		if (!addAnnotation(doc, heading, doms, "Was ist Aufklärung?",
+		if (!addAnnotation(logger, doc, heading, "Was ist Aufklärung?",
 		                   "emphasized")) {
 			return {nullptr};
 		}
@@ -232,58 +233,57 @@ static Rooted<Document> constructAdvancedDocument(Manager &mgr,
 
 	// Add the main section.
 	Rooted<StructuredEntity> sec =
-	    StructuredEntity::buildEntity(book, doms, "section");
+	    buildStructuredEntity(doc, logger, book, {"section"});
 	if (sec.isNull()) {
 		return {nullptr};
 	}
 
 	// Add the heading.
-	if (!addHeading(sec, doms, "Was ist Aufklärung?")) {
+	if (!addHeading(logger, doc, sec, "Was ist Aufklärung?")) {
 		return {nullptr};
 	}
 
 	// Add paragraph with main text.
 	{
 		Rooted<StructuredEntity> p =
-		    StructuredEntity::buildEntity(sec, doms, "paragraph");
+		    buildStructuredEntity(doc, logger, sec, {"paragraph"});
 		if (p.isNull()) {
 			return {nullptr};
 		}
 		// Add its text.
 		{
-			if (!addAnnotation(doc, p, doms,
+			if (!addAnnotation(logger, doc, p,
 			                   "Aufklärung ist der Ausgang des Menschen aus "
 			                   "seiner selbstverschuldeten Unmündigkeit",
 			                   "strong")) {
 				return {nullptr};
 			}
-			if (!addAnnotation(doc, p, doms, "Unmündigkeit",
-			                   "emphasized")) {
+			if (!addAnnotation(logger, doc, p, "Unmündigkeit", "emphasized")) {
 				return {nullptr};
 			}
-			if (!addText(p, doms,
+			if (!addText(logger, doc, p,
 			             "ist das Unvermögen, sich seines Verstandes ohne "
 			             "Leitung eines anderen zu bedienen. ")) {
 				return {nullptr};
 			}
-			if (!addAnnotation(doc, p, doms, "Selbstverschuldet",
+			if (!addAnnotation(logger, doc, p, "Selbstverschuldet",
 			                   "emphasized")) {
 				return {nullptr};
 			}
-			if (!addText(p, doms,
+			if (!addText(logger, doc, p,
 			             " ist diese Unmündigkeit, wenn die Ursache derselben "
 			             "nicht am Mangel des Verstandes, sondern der "
 			             "Entschließung und des Mutes liegt, sich seiner ohne "
 			             "Leitung eines andern zu bedienen.")) {
 				return {nullptr};
 			}
-			if (!addAnnotation(doc, p, doms,
+			if (!addAnnotation(logger, doc, p,
 			                   "Sapere aude! Habe Mut, dich deines eigenen "
 			                   "Verstandes zu bedienen!",
 			                   "emphasized")) {
 				return {nullptr};
 			}
-			if (!addText(p, doms,
+			if (!addText(logger, doc, p,
 			             " ist also der Wahlspruch der Aufklärung.")) {
 				return {nullptr};
 			}
@@ -292,20 +292,18 @@ static Rooted<Document> constructAdvancedDocument(Manager &mgr,
 
 	// Add the "Lesarten" section
 	Rooted<StructuredEntity> lesarten =
-	    StructuredEntity::buildEntity(book, doms, "section");
+	    buildStructuredEntity(doc, logger, book, {"section"});
 	if (lesarten.isNull()) {
 		return {nullptr};
 	}
 	// Add the heading.
-	if (!addHeading(lesarten, doms, "Lesarten")) {
+	if (!addHeading(logger, doc, lesarten, "Lesarten")) {
 		return {nullptr};
 	}
 	// Add list with citations
 	{
-		// TODO: We need to restrict this to the list domain. Otherwise
-		// this leads to resolve errors for some reason.
 		Rooted<StructuredEntity> ul =
-		    StructuredEntity::buildEntity(lesarten, {listDom}, "ul");
+		    buildStructuredEntity(doc, logger, lesarten, {"ul"});
 		if (ul.isNull()) {
 			return {nullptr};
 		}
@@ -323,13 +321,12 @@ static Rooted<Document> constructAdvancedDocument(Manager &mgr,
 		    "von F. Ch. Starke. 2 Bände. Leipzig 1833 und Quedlinburg 1838. "
 		    "Bd. I, S. 75–84."};
 		for (auto &cit : citations) {
-			// TODO: This needs to be restricted as well.
 			Rooted<StructuredEntity> item =
-			    StructuredEntity::buildEntity(ul, {listDom}, "item");
+			    buildStructuredEntity(doc, logger, ul, {"item"});
 			if (item.isNull()) {
 				return {nullptr};
 			}
-			if (!addText(item, doms, cit)) {
+			if (!addText(logger, doc, item, cit)) {
 				return {nullptr};
 			}
 		}
diff --git a/test/core/model/TestDocument.hpp b/test/core/model/TestDocument.hpp
index 6b0267a..eaec42c 100644
--- a/test/core/model/TestDocument.hpp
+++ b/test/core/model/TestDocument.hpp
@@ -23,6 +23,8 @@
 #include <core/model/Domain.hpp>
 #include <core/model/Typesystem.hpp>
 
+#include "TestDocumentBuilder.hpp"
+
 namespace ousia {
 namespace model {
 
@@ -30,57 +32,58 @@ namespace model {
  * This constructs a fairly simple test document for the "book" domain. The
  * structure of the document can be seen in the Code below.
  */
-static Rooted<Document> constructBookDocument(Manager &mgr,
+static Rooted<Document> constructBookDocument(Manager &mgr, Logger &logger,
                                               Rooted<Domain> bookDomain)
 {
 	// Start with the (empty) document.
 	Rooted<Document> doc{new Document(mgr, "myDoc.oxd")};
+	doc->addDomain(bookDomain);
 
 	// Add the root.
 	Rooted<StructuredEntity> root =
-	    StructuredEntity::buildRootEntity(doc, {bookDomain}, "book");
+	    buildRootStructuredEntity(doc, logger, {"book"});
 	if (root.isNull()) {
 		return {nullptr};
 	}
 
 	// Add a paragraph.
 	Rooted<StructuredEntity> foreword =
-	    StructuredEntity::buildEntity(root, {bookDomain}, "paragraph");
+	    buildStructuredEntity(doc, logger, root, {"paragraph"});
 	if (foreword.isNull()) {
 		return {nullptr};
 	}
 	// Add its text.
 	Rooted<StructuredEntity> foreword_text =
-	    StructuredEntity::buildEntity(foreword, {bookDomain}, "text");
+	    buildStructuredEntity(doc, logger, foreword, {"text"});
 	if (foreword_text.isNull()) {
 		return {nullptr};
 	}
 	// And its primitive content
 	Variant text{"Some introductory text"};
 	Rooted<DocumentPrimitive> foreword_primitive =
-	    DocumentPrimitive::buildEntity(foreword_text, text, "content");
+	    buildPrimitiveEntity(logger, foreword_text, text, "content");
 	if (foreword_primitive.isNull()) {
 		return {nullptr};
 	}
 	// Add a section.
 	Rooted<StructuredEntity> section =
-	    StructuredEntity::buildEntity(root, {bookDomain}, "section");
+	    buildStructuredEntity(doc, logger, root, {"section"});
 	// Add a paragraph for it.
 	Rooted<StructuredEntity> main =
-	    StructuredEntity::buildEntity(section, {bookDomain}, "paragraph");
+	    buildStructuredEntity(doc, logger, section, {"paragraph"});
 	if (main.isNull()) {
 		return {nullptr};
 	}
 	// Add its text.
 	Rooted<StructuredEntity> main_text =
-	    StructuredEntity::buildEntity(main, {bookDomain}, "text");
+	    buildStructuredEntity(doc, logger, main, {"text"});
 	if (main_text.isNull()) {
 		return {nullptr};
 	}
 	// And its primitive content
 	text = Variant{"Some actual text"};
 	Rooted<DocumentPrimitive> main_primitive =
-	    DocumentPrimitive::buildEntity(main_text, text, "content");
+	    buildPrimitiveEntity(logger, main_text, text, "content");
 	if (main_primitive.isNull()) {
 		return {nullptr};
 	}
diff --git a/test/core/model/TestDocumentBuilder.hpp b/test/core/model/TestDocumentBuilder.hpp
new file mode 100644
index 0000000..0c6ca34
--- /dev/null
+++ b/test/core/model/TestDocumentBuilder.hpp
@@ -0,0 +1,300 @@
+/*
+    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_DOCUMENT_BUILDER_HPP_
+#define _MODEL_TEST_DOCUMENT_BUILDER_HPP_
+
+#include <sstream>
+
+#include <core/common/Logger.hpp>
+#include <core/model/Document.hpp>
+#include <core/model/Domain.hpp>
+#include <core/model/Typesystem.hpp>
+
+namespace ousia {
+namespace model {
+
+typedef std::vector<std::string> Path;
+
+/* Class StructuredEntity */
+
+static std::string getPathString(const Path &path)
+{
+	std::stringstream ss;
+	ss << path[0];
+	for (size_t i = 1; i < path.size(); i++) {
+		ss << '.';
+		ss << path[i];
+	}
+	return std::move(ss.str());
+}
+
+static Rooted<Descriptor> resolveDescriptor(Handle<Document> doc,
+                                            Logger &logger, const Path &path,
+                                            const RttiBase &type)
+{
+	// use the actual resolve method.
+	std::vector<ResolutionResult> resolved = doc->resolve(path, type);
+	// if we don't find anything, log an error
+	if (resolved.size() == 0) {
+		logger.error(std::string("Could not resolve ") + getPathString(path));
+		return {nullptr};
+	}
+	// if we have more than one result, log an error.
+	if (resolved.size() > 1) {
+		logger.error(getPathString(path) + " was ambigous: ");
+		for (auto &r : resolved) {
+			logger.error(getPathString(r.node->path()));
+		}
+	}
+	// Return the resulting node.
+	return resolved[0].node.cast<Descriptor>();
+}
+
+/**
+ * This builds the root StructuredEntity for the given document. It
+ * automatically appends the newly build entity to the given document.
+ *
+ * @param document   is the document this entity shall be build for. The
+ *                   resulting entity will automatically be appended to that
+ *                   document. Also the manager of that document will be
+ *                   used to register the new node.
+ * @param logger     is the current logger.
+ * @param path       is the name of the StructuredClass or a path specifying it
+ *                   uniquely.
+ * @param attributes are the attributes of the new node in terms of a Struct
+ *                   variant (empty per default).
+ * @param name       is the name of this StructuredEntity (empty per
+ *                   default).
+ * @return           the newly created StructuredEntity or a nullptr if some
+ *                   input handle was empty or the given domains did not
+ *                   contain a StructuredClass with the given name.
+ */
+Rooted<StructuredEntity> buildRootStructuredEntity(Handle<Document> document,
+                                                   Logger &logger,
+                                                   const Path &path,
+                                                   Variant attributes = {},
+                                                   std::string name = "")
+{
+	// If the parent is not set, we can not build the entity.
+	if (document == nullptr) {
+		logger.error("The input document handle was null!");
+		return {nullptr};
+	}
+	// If we can not find the correct descriptor, we can not build the entity
+	// either.
+	Rooted<Descriptor> descriptor =
+	    resolveDescriptor(document, logger, path, RttiTypes::StructuredClass);
+	if (descriptor == nullptr) {
+		return {nullptr};
+	}
+	// Then construct the StructuredEntity itself.
+	Rooted<StructuredEntity> root{new StructuredEntity(
+	    document->getManager(), document, descriptor.cast<StructuredClass>(),
+	    attributes, std::move(name))};
+	// append it to the document.
+	document->setRoot(root);
+	// and return it.
+	return root;
+}
+
+/**
+ * This builds a StructuredEntity as child of the given DocumentEntity. It
+ * automatically appends the newly build entity to its parent.
+ *
+ * @param document   is the document this entity shall be build for. The domains
+ *                   referenced here are the basis to resolve the given path.
+ * @param logger     is the current logger.
+ * @param parent     is the parent DocumentEntity. The newly constructed
+ *                   StructuredEntity will automatically be appended to it.
+ * @param path       is the name of the StructuredClass or a path specifying it
+ *                   uniquely.
+ * @param fieldName  is the name of the field where the newly constructed
+ *                   StructuredEntity shall be appended.
+ * @param attributes are the attributes of the new node in terms of a Struct
+ *                   variant (empty per default).
+ * @param name       is the name of this StructuredEntity (empty per
+ *                   default).
+ * @return           the newly created StructuredEntity or a nullptr if some
+ *                   input handle was empty or the given domains did not
+ *                   contain a StructuredClass with the given name.
+ */
+Rooted<StructuredEntity> buildStructuredEntity(
+    Handle<Document> document, Logger &logger, Handle<DocumentEntity> parent,
+    Path path, const std::string &fieldName = "", Variant attributes = {},
+    std::string name = "")
+{
+	// If the input handles are not set, we can not build the entity.
+	if (parent == nullptr) {
+		logger.error("The input parent handle was null!");
+		return {nullptr};
+	}
+	if (document == nullptr) {
+		logger.error("The input document handle was null!");
+		return {nullptr};
+	}
+	// If we can not find the correct descriptor, we can not build the entity
+	// either.
+	Rooted<Descriptor> descriptor =
+	    resolveDescriptor(document, logger, path, RttiTypes::StructuredClass);
+	if (descriptor == nullptr) {
+		return {nullptr};
+	}
+	// Then construct the StructuredEntity itself.
+	Rooted<StructuredEntity> entity{new StructuredEntity(
+	    parent->getManager(), parent, descriptor.cast<StructuredClass>(),
+	    attributes, std::move(name))};
+	// if the field does not exist, return null handle as well.
+	if (!parent->hasField(fieldName)) {
+		logger.error(std::string("The parent has no field of the name ") +
+		             fieldName + "!");
+		return {nullptr};
+	}
+	NodeVector<StructuredEntity> &field = parent->getField(fieldName);
+	field.push_back(entity);
+
+	// and return it.
+	return entity;
+}
+
+/**
+ * This builds a DocumentPrimitive as child of the given DocumentEntity. It
+ * automatically appends the newly build entity to its parent.
+ *
+ * @param logger     is the current logger.
+ * @param parent     is the parent DocumentEntity. The newly constructed
+ *                   DocumentPrimitive will automatically be appended to it.
+ * @param content    is the primitive content of the new node in terms of a
+ *                   Struct variant.
+ * @param fieldName  is the name of the field where the newly constructed
+ *                   StructuredEntity shall be appended.
+ *
+ * @return           the newly created DocumentPrimitive or a nullptr if some
+ *                   input handle was empty.
+ */
+Rooted<DocumentPrimitive> buildPrimitiveEntity(
+    Logger &logger, Handle<DocumentEntity> parent, Variant content = {},
+    const std::string &fieldName = "")
+{
+	// If the input handles are not set, we can not build the entity.
+	if (parent == nullptr) {
+		logger.error("The input parent handle was null!");
+		return {nullptr};
+	}
+	// Then construct the StructuredEntity itself.
+	Rooted<DocumentPrimitive> entity{
+	    new DocumentPrimitive(parent->getManager(), parent, content)};
+	// if the field does not exist, return null handle as well.
+	if (!parent->hasField(fieldName)) {
+		logger.error(std::string("The parent has no field of the name ") +
+		             fieldName + "!");
+		return {nullptr};
+	}
+	NodeVector<StructuredEntity> &field = parent->getField(fieldName);
+	field.push_back(entity);
+	// and return it.
+	return entity;
+}
+
+/**
+ * This builds an Anchor as child of the given DocumentEntity. It
+ * automatically appends the newly build Anchor to its parent.
+ *
+ * @param logger     is the current logger.
+ * @param parent     is the parent DocumentEntity. The newly constructed
+ *                   Anchor will automatically be appended to it.
+ * @param id         is the id of this Anchor.
+ * @param fieldName  is the name of the field where the newly constructed
+ *                   Anchor shall be appended.
+ *
+ * @return           the newly created Anchor or a nullptr if some
+ *                   input handle was empty.
+ */
+Rooted<AnnotationEntity::Anchor> buildAnchor(Logger &logger,
+                                             Handle<DocumentEntity> parent,
+                                             std::string id,
+                                             const std::string &fieldName = "")
+{
+	// If the parent is not set, we can not build the anchor.
+	if (parent == nullptr) {
+		logger.error("The input parent handle was null!");
+		return {nullptr};
+	}
+	// Then construct the Anchor itself
+	Rooted<AnnotationEntity::Anchor> anchor{
+	    new AnnotationEntity::Anchor(parent->getManager(), parent, id)};
+	// append the new entity to the right field.
+	if (!parent->hasField(fieldName)) {
+		logger.error(std::string("The parent has no field of the name ") +
+		             fieldName + "!");
+		return {nullptr};
+	}
+	NodeVector<StructuredEntity> &field = parent->getField(fieldName);
+	field.push_back(anchor);
+	// and return it.
+	return anchor;
+}
+/**
+ * This builds an AnnotationEntity as child of the given Document. It
+ * automatically appends the newly build entity to its parent.
+ *
+ * @param document   is the document this entity shall be build for. The domains
+ *                   referenced here are the basis to resolve the given path.
+ * @param logger     is the current logger.
+ * @param path       is the name of the AnnotationClass or a path specifying it
+ *                   uniquely.
+ * @param start      is the start Anchor for this AnnotationEntity.
+ * @param end        is the end Anchor for this AnnotationEntity.
+ * @param attributes are the attributes of the new node in terms of a Struct
+ *                   variant (empty per default).
+ * @param name       is the name of this AnnotationEntity (empty per
+ *                   default).
+ * @return           the newly created AnnotationEntity or a nullptr if some
+ *                   input handle was empty or the given domains did not
+ *                   contain a AnnotationClass with the given name.
+ */
+Rooted<AnnotationEntity> buildAnnotationEntity(
+    Handle<Document> document, Logger &logger, const Path &path,
+    Handle<AnnotationEntity::Anchor> start,
+    Handle<AnnotationEntity::Anchor> end, Variant attributes = {},
+    std::string name = "")
+{
+	// If the input handles are not set, we can not build the entity.
+	if (document == nullptr) {
+		logger.error("The input document handle was null!");
+		return {nullptr};
+	}
+	// If we can not find the correct descriptor, we can not build the
+	// entity either.
+	Rooted<Descriptor> descriptor =
+	    resolveDescriptor(document, logger, path, RttiTypes::AnnotationClass);
+	if (descriptor == nullptr) {
+		return {nullptr};
+	}
+	// Then construct the AnnotationEntity itself
+	Rooted<AnnotationEntity> anno{new AnnotationEntity(
+	    document->getManager(), document, descriptor.cast<AnnotationClass>(),
+	    attributes, start, end, name)};
+	// append the new entity to the document
+	document->getAnnotations().push_back(anno);
+	// and return it.
+	return anno;
+}
+}
+}
+#endif
diff --git a/test/plugins/html/DemoOutputTest.cpp b/test/plugins/html/DemoOutputTest.cpp
index 36b53b4..4ab2c53 100644
--- a/test/plugins/html/DemoOutputTest.cpp
+++ b/test/plugins/html/DemoOutputTest.cpp
@@ -26,7 +26,6 @@
 #include <core/model/Domain.hpp>
 
 #include <core/model/TestAdvanced.hpp>
-#include <core/model/TestDocument.hpp>
 #include <core/model/TestDomain.hpp>
 
 namespace ousia {
@@ -35,7 +34,7 @@ namespace html {
 TEST(DemoHTMLTransformer, writeHTML)
 {
 	// Construct Manager
-	Logger logger;
+	TerminalLogger logger{std::cerr, true};
 	Manager mgr{1};
 	Rooted<model::SystemTypesystem> sys{new model::SystemTypesystem(mgr)};
 	// Get the domains.
@@ -48,8 +47,8 @@ TEST(DemoHTMLTransformer, writeHTML)
 	Rooted<model::Domain> emDom =
 	    model::constructEmphasisDomain(mgr, sys, logger);
 	// Construct the document.
-	Rooted<model::Document> doc =
-	    model::constructAdvancedDocument(mgr, bookDom, headingDom, listDom);
+	Rooted<model::Document> doc = model::constructAdvancedDocument(
+	    mgr, logger, bookDom, headingDom, listDom, emDom);
 
 #ifdef MANAGER_GRAPHVIZ_EXPORT
 	// dump the manager state