reworked test for domain parsing. The skeleton works.

1 files changed, 94 insertions, 9 deletions

diff --git a/test/plugins/xml/XmlParserTest.cpp b/test/plugins/xml/XmlParserTest.cpp
index b90f39e..60e7c9b 100644
--- a/test/plugins/xml/XmlParserTest.cpp
+++ b/test/plugins/xml/XmlParserTest.cpp
@@ -23,6 +23,7 @@
 #include <core/common/CharReader.hpp>
 #include <core/common/SourceContextReader.hpp>
 #include <core/model/Domain.hpp>
+#include <core/model/Node.hpp>
 #include <core/model/Project.hpp>
 #include <core/frontend/TerminalLogger.hpp>
 #include <core/StandaloneEnvironment.hpp>
@@ -73,26 +74,110 @@ TEST(XmlParser, generic)
 #endif
 }
 
+static void checkStructuredClass(
+    Handle<Node> n, const std::string &name, Handle<Domain> domain,
+    Variant cardinality = AnyCardinality,
+    Handle<StructType> attributesDescriptor = nullptr,
+    Handle<StructuredClass> superclass = nullptr, bool transparent = false,
+    bool root = false)
+{
+	ASSERT_FALSE(n == nullptr);
+	Handle<StructuredClass> sc = n.cast<StructuredClass>();
+	ASSERT_FALSE(sc == nullptr);
+	ASSERT_EQ(name, sc->getName());
+	ASSERT_EQ(domain, sc->getParent());
+	ASSERT_EQ(cardinality, sc->getCardinality());
+	ASSERT_EQ(transparent, sc->isTransparent());
+	ASSERT_EQ(root, sc->hasRootPermission());
+}
+
+static Rooted<StructuredClass> checkStructuredClass(
+    const std::string &resolve, const std::string &name, Handle<Domain> domain,
+    Variant cardinality = AnyCardinality,
+    Handle<StructType> attributesDescriptor = nullptr,
+    Handle<StructuredClass> superclass = nullptr, bool transparent = false,
+    bool root = false)
+{
+	auto res = domain->resolve(RttiTypes::StructuredClass, resolve);
+	if (res.size() != 1) {
+		throw OusiaException("resolution error!");
+	}
+	Handle<StructuredClass> sc = res[0].node.cast<StructuredClass>();
+	checkStructuredClass(sc, name, domain, cardinality, attributesDescriptor,
+	                     superclass, transparent, root);
+	return sc;
+}
+
+static void checkFieldDescriptor(
+    Handle<Node> n, const std::string &name, Handle<Descriptor> parent,
+    NodeVector<StructuredClass> children,
+    FieldDescriptor::FieldType type = FieldDescriptor::FieldType::TREE,
+    Handle<Type> primitiveType = nullptr, bool optional = false)
+{
+	ASSERT_FALSE(n.isNull());
+	Handle<FieldDescriptor> field = n.cast<FieldDescriptor>();
+	ASSERT_FALSE(field.isNull());
+	ASSERT_EQ(name, field->getName());
+	ASSERT_EQ(parent, field->getParent());
+	ASSERT_EQ(type, field->getFieldType());
+	ASSERT_EQ(primitiveType, field->getPrimitiveType());
+	ASSERT_EQ(optional, field->isOptional());
+	// check the children.
+	ASSERT_EQ(children.size(), field->getChildren().size());
+	for (unsigned int c = 0; c < children.size(); c++) {
+		ASSERT_EQ(children[c], field->getChildren()[c]);
+	}
+}
+
+static void checkFieldDescriptor(
+    Handle<Descriptor> desc, NodeVector<StructuredClass> children,
+    const std::string &name = "",
+    FieldDescriptor::FieldType type = FieldDescriptor::FieldType::TREE,
+    Handle<Type> primitiveType = nullptr, bool optional = false)
+{
+	auto res = desc->resolve(RttiTypes::FieldDescriptor, name);
+	ASSERT_EQ(1, res.size());
+	checkFieldDescriptor(res[0].node, name, desc, children, type, primitiveType,
+	                     optional);
+}
+
 TEST(XmlParser, domainParsing)
 {
 	XmlStandaloneEnvironment env(logger);
 	Rooted<Node> n =
 	    env.parse("book_domain.oxm", "", "", RttiSet{&RttiTypes::Domain});
-	ASSERT_FALSE(n.isNull());
+	ASSERT_FALSE(n == nullptr);
+	ASSERT_FALSE(logger.hasError());
 	// check the domain node.
 	Rooted<Domain> domain = n.cast<Domain>();
 	ASSERT_EQ("book", domain->getName());
 	// get the book struct node.
-	auto res = domain->resolve(RttiTypes::StructuredClass, "book");
-	ASSERT_EQ(1, res.size());
-	Rooted<StructuredClass> bookStruct = res[0].node.cast<StructuredClass>();
-	ASSERT_EQ("book", bookStruct->getName());
 	Cardinality single;
 	single.merge({1});
-	ASSERT_EQ(single, bookStruct->getCardinality());
-	//TODO: Something is wrong here
-//	ASSERT_TRUE(bookStruct->isRoot());
-	ASSERT_FALSE(bookStruct->isTransparent());
+	Rooted<StructuredClass> book = checkStructuredClass(
+	    "book", "book", domain, single, nullptr, nullptr, false, true);
+	// get the chapter struct node.
+	Rooted<StructuredClass> chapter =
+	    checkStructuredClass("chapter", "chapter", domain);
+	Rooted<StructuredClass> section =
+	    checkStructuredClass("section", "section", domain);
+	Rooted<StructuredClass> subsection =
+	    checkStructuredClass("subsection", "subsection", domain);
+	Rooted<StructuredClass> paragraph =
+	    checkStructuredClass("paragraph", "paragraph", domain, AnyCardinality,
+	                         nullptr, nullptr, true, false);
+	Rooted<StructuredClass> text = checkStructuredClass(
+	    "text", "text", domain, AnyCardinality, nullptr, nullptr, true, false);
+
+	// check the FieldDescriptors.
+	checkFieldDescriptor(book, {chapter, paragraph});
+	checkFieldDescriptor(chapter, {section, paragraph});
+	checkFieldDescriptor(section, {subsection, paragraph});
+	checkFieldDescriptor(subsection, {paragraph});
+	checkFieldDescriptor(paragraph, {text});
+	checkFieldDescriptor(
+	    text, {}, "content", FieldDescriptor::FieldType::PRIMITIVE,
+	    env.project->getSystemTypesystem()->getStringType(), false);
 }
 }