summaryrefslogtreecommitdiff
path: root/test/formats/osxml/OsxmlParserTest.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'test/formats/osxml/OsxmlParserTest.cpp')
-rw-r--r--test/formats/osxml/OsxmlParserTest.cpp80
1 files changed, 40 insertions, 40 deletions
diff --git a/test/formats/osxml/OsxmlParserTest.cpp b/test/formats/osxml/OsxmlParserTest.cpp
index 3bf4a47..79dd58b 100644
--- a/test/formats/osxml/OsxmlParserTest.cpp
+++ b/test/formats/osxml/OsxmlParserTest.cpp
@@ -23,7 +23,7 @@
#include <core/common/CharReader.hpp>
#include <core/common/SourceContextReader.hpp>
#include <core/model/Document.hpp>
-#include <core/model/Domain.hpp>
+#include <core/model/Ontology.hpp>
#include <core/model/Node.hpp>
#include <core/model/Project.hpp>
#include <core/frontend/TerminalLogger.hpp>
@@ -36,7 +36,7 @@ namespace ousia {
namespace RttiTypes {
extern const Rtti Document;
-extern const Rtti Domain;
+extern const Rtti Ontology;
extern const Rtti Typesystem;
}
@@ -88,7 +88,7 @@ static void checkAttributes(Handle<StructType> expected,
}
static void checkStructuredClass(
- Handle<Node> n, const std::string &name, Handle<Domain> domain,
+ Handle<Node> n, const std::string &name, Handle<Ontology> ontology,
Variant cardinality = Cardinality::any(),
Handle<StructType> attributesDescriptor = nullptr,
Handle<StructuredClass> superclass = nullptr, bool transparent = false,
@@ -98,7 +98,7 @@ static void checkStructuredClass(
Handle<StructuredClass> sc = n.cast<StructuredClass>();
ASSERT_FALSE(sc == nullptr);
ASSERT_EQ(name, sc->getName());
- ASSERT_EQ(domain, sc->getParent());
+ ASSERT_EQ(ontology, sc->getParent());
ASSERT_EQ(cardinality, sc->getCardinality());
ASSERT_EQ(transparent, sc->isTransparent());
ASSERT_EQ(root, sc->hasRootPermission());
@@ -106,44 +106,44 @@ static void checkStructuredClass(
}
static Rooted<StructuredClass> checkStructuredClass(
- const std::string &resolve, const std::string &name, Handle<Domain> domain,
+ const std::string &resolve, const std::string &name, Handle<Ontology> ontology,
Variant cardinality = Cardinality::any(),
Handle<StructType> attributesDescriptor = nullptr,
Handle<StructuredClass> superclass = nullptr, bool transparent = false,
bool root = false)
{
- auto res = domain->resolve(&RttiTypes::StructuredClass, resolve);
+ auto res = ontology->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,
+ checkStructuredClass(sc, name, ontology, cardinality, attributesDescriptor,
superclass, transparent, root);
return sc;
}
static void checkAnnotationClass(
- Handle<Node> n, const std::string &name, Handle<Domain> domain,
+ Handle<Node> n, const std::string &name, Handle<Ontology> ontology,
Handle<StructType> attributesDescriptor = nullptr)
{
ASSERT_FALSE(n == nullptr);
Handle<AnnotationClass> ac = n.cast<AnnotationClass>();
ASSERT_FALSE(ac == nullptr);
ASSERT_EQ(name, ac->getName());
- ASSERT_EQ(domain, ac->getParent());
+ ASSERT_EQ(ontology, ac->getParent());
checkAttributes(attributesDescriptor, ac);
}
static Rooted<AnnotationClass> checkAnnotationClass(
- const std::string &resolve, const std::string &name, Handle<Domain> domain,
+ const std::string &resolve, const std::string &name, Handle<Ontology> ontology,
Handle<StructType> attributesDescriptor = nullptr)
{
- auto res = domain->resolve(&RttiTypes::AnnotationClass, resolve);
+ auto res = ontology->resolve(&RttiTypes::AnnotationClass, resolve);
if (res.size() != 1) {
throw OusiaException("resolution error!");
}
Handle<AnnotationClass> ac = res[0].node.cast<AnnotationClass>();
- checkAnnotationClass(ac, name, domain, attributesDescriptor);
+ checkAnnotationClass(ac, name, ontology, attributesDescriptor);
return ac;
}
@@ -192,33 +192,33 @@ static void checkFieldDescriptor(
optional);
}
-TEST(OsxmlParser, domainParsing)
+TEST(OsxmlParser, ontologyParsing)
{
XmlStandaloneEnvironment env(logger);
- Rooted<Node> book_domain_node =
- env.parse("book_domain.osxml", "", "", RttiSet{&RttiTypes::Domain});
- ASSERT_FALSE(book_domain_node == nullptr);
+ Rooted<Node> book_ontology_node =
+ env.parse("book_ontology.osxml", "", "", RttiSet{&RttiTypes::Ontology});
+ ASSERT_FALSE(book_ontology_node == nullptr);
ASSERT_FALSE(logger.hasError());
- // check the domain node.
- Rooted<Domain> book_domain = book_domain_node.cast<Domain>();
- ASSERT_EQ("book", book_domain->getName());
+ // check the ontology node.
+ Rooted<Ontology> book_ontology = book_ontology_node.cast<Ontology>();
+ ASSERT_EQ("book", book_ontology->getName());
// get the book struct node.
Cardinality single;
single.merge({1});
Rooted<StructuredClass> book = checkStructuredClass(
- "book", "book", book_domain, single, nullptr, nullptr, false, true);
+ "book", "book", book_ontology, single, nullptr, nullptr, false, true);
// get the chapter struct node.
Rooted<StructuredClass> chapter =
- checkStructuredClass("chapter", "chapter", book_domain);
+ checkStructuredClass("chapter", "chapter", book_ontology);
Rooted<StructuredClass> section =
- checkStructuredClass("section", "section", book_domain);
+ checkStructuredClass("section", "section", book_ontology);
Rooted<StructuredClass> subsection =
- checkStructuredClass("subsection", "subsection", book_domain);
+ checkStructuredClass("subsection", "subsection", book_ontology);
Rooted<StructuredClass> paragraph =
- checkStructuredClass("paragraph", "paragraph", book_domain,
+ checkStructuredClass("paragraph", "paragraph", book_ontology,
Cardinality::any(), nullptr, nullptr, true, false);
Rooted<StructuredClass> text =
- checkStructuredClass("text", "text", book_domain, Cardinality::any(),
+ checkStructuredClass("text", "text", book_ontology, Cardinality::any(),
nullptr, nullptr, true, false);
// check the FieldDescriptors.
@@ -231,19 +231,19 @@ TEST(OsxmlParser, domainParsing)
text, {}, "", FieldDescriptor::FieldType::TREE,
env.project->getSystemTypesystem()->getStringType(), false);
- // check parent handling using the headings domain.
- Rooted<Node> headings_domain_node =
- env.parse("headings_domain.osxml", "", "", RttiSet{&RttiTypes::Domain});
- ASSERT_FALSE(headings_domain_node == nullptr);
+ // check parent handling using the headings ontology.
+ Rooted<Node> headings_ontology_node =
+ env.parse("headings_ontology.osxml", "", "", RttiSet{&RttiTypes::Ontology});
+ ASSERT_FALSE(headings_ontology_node == nullptr);
ASSERT_FALSE(logger.hasError());
- Rooted<Domain> headings_domain = headings_domain_node.cast<Domain>();
+ Rooted<Ontology> headings_ontology = headings_ontology_node.cast<Ontology>();
// now there should be a heading struct.
Rooted<StructuredClass> heading =
- checkStructuredClass("heading", "heading", headings_domain, single,
+ checkStructuredClass("heading", "heading", headings_ontology, single,
nullptr, nullptr, true, false);
// which should be a reference to the paragraph descriptor.
checkFieldDescriptor(heading, paragraph, {text});
- // and each struct in the book domain (except for text) should have a
+ // and each struct in the book ontology (except for text) should have a
// heading field now.
checkFieldDescriptor(book, {heading}, "heading",
FieldDescriptor::FieldType::SUBTREE, nullptr, true);
@@ -256,21 +256,21 @@ TEST(OsxmlParser, domainParsing)
checkFieldDescriptor(paragraph, {heading}, "heading",
FieldDescriptor::FieldType::SUBTREE, nullptr, true);
- // check annotation handling using the comments domain.
- Rooted<Node> comments_domain_node =
- env.parse("comments_domain.osxml", "", "", RttiSet{&RttiTypes::Domain});
- ASSERT_FALSE(comments_domain_node == nullptr);
+ // check annotation handling using the comments ontology.
+ Rooted<Node> comments_ontology_node =
+ env.parse("comments_ontology.osxml", "", "", RttiSet{&RttiTypes::Ontology});
+ ASSERT_FALSE(comments_ontology_node == nullptr);
ASSERT_FALSE(logger.hasError());
- Rooted<Domain> comments_domain = comments_domain_node.cast<Domain>();
+ Rooted<Ontology> comments_ontology = comments_ontology_node.cast<Ontology>();
// now we should be able to find a comment annotation.
Rooted<AnnotationClass> comment_anno =
- checkAnnotationClass("comment", "comment", comments_domain);
+ checkAnnotationClass("comment", "comment", comments_ontology);
// as well as a comment struct
Rooted<StructuredClass> comment =
- checkStructuredClass("comment", "comment", comments_domain);
+ checkStructuredClass("comment", "comment", comments_ontology);
// and a reply struct
Rooted<StructuredClass> reply =
- checkStructuredClass("reply", "reply", comments_domain);
+ checkStructuredClass("reply", "reply", comments_ontology);
// check the fields for each of them.
{
std::vector<Rooted<Descriptor>> descs{comment_anno, comment, reply};
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-30 16:57:01 +0000