Merge branch 'develop'v0.23.03

1 files changed, 81 insertions, 254 deletions

diff --git a/test/schema/test_schema.py b/test/schema/test_schema.py
index 888cdca..f52cf95 100644
--- a/test/schema/test_schema.py
+++ b/test/schema/test_schema.py
@@ -1,16 +1,11 @@
-"""
 
-Part of the tagit test suite.
-A copy of the license is provided with the project.
-Author: Matthias Baumgartner, 2022
-"""
 # imports
 import operator
 import unittest
 
 # bsfs imports
 from bsfs.namespace import ns
-from bsfs.schema import types
+from bsfs.schema import types, from_string
 from bsfs.utils import errors
 
 # objects to test
@@ -19,6 +14,8 @@ from bsfs.schema.schema import Schema
 
 ## code ##
 
+ns.bse = ns.bsfs.Entity()
+
 class TestSchema(unittest.TestCase):
 
     def setUp(self):
@@ -26,8 +23,9 @@ class TestSchema(unittest.TestCase):
             prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
             prefix xsd: <http://www.w3.org/2001/XMLSchema#>
 
-            prefix bsfs: <http://bsfs.ai/schema/>
-            prefix bse: <http://bsfs.ai/schema/Entity#>
+            prefix bsfs: <https://schema.bsfs.io/core/>
+            prefix bse: <https://schema.bsfs.io/core/Entity#>
+            prefix bsl: <https://schema.bsfs.io/core/Literal>
 
             bsfs:Entity rdfs:subClassOf bsfs:Node .
             bsfs:Tag rdfs:subClassOf bsfs:Node .
@@ -35,7 +33,8 @@ class TestSchema(unittest.TestCase):
             bsfs:Unused rdfs:subClassOf bsfs:Node .
 
             xsd:string rdfs:subClassOf bsfs:Literal .
-            xsd:integer rdfs:subClassOf bsfs:Literal .
+            bsfs:Number rdfs:subClassOf bsfs:Literal .
+            xsd:integer rdfs:subClassOf bsl:Number .
             xsd:boolean rdfs:subClassOf bsfs:Literal .
 
             bse:tag rdfs:subClassOf bsfs:Predicate ;
@@ -55,32 +54,43 @@ class TestSchema(unittest.TestCase):
 
             '''
         # nodes
-        self.n_root = types.Node(ns.bsfs.Node, None)
-        self.n_ent = types.Node(ns.bsfs.Entity, types.Node(ns.bsfs.Node, None))
-        self.n_img = types.Node(ns.bsfs.Image, types.Node(ns.bsfs.Entity, types.Node(ns.bsfs.Node, None)))
-        self.n_tag = types.Node(ns.bsfs.Tag, types.Node(ns.bsfs.Node, None))
-        self.n_unused = types.Node(ns.bsfs.Unused, types.Node(ns.bsfs.Node, None))
+        self.n_root = types.ROOT_NODE
+        self.n_ent = self.n_root.child(ns.bsfs.Entity)
+        self.n_img = self.n_ent.child(ns.bsfs.Image)
+        self.n_tag = self.n_root.child(ns.bsfs.Tag)
+        self.n_unused = self.n_root.child(ns.bsfs.Unused)
         self.nodes = [self.n_root, self.n_ent, self.n_img, self.n_tag, self.n_unused]
 
         # literals
-        self.l_root = types.Literal(ns.bsfs.Literal, None)
-        self.l_string = types.Literal(ns.xsd.string, types.Literal(ns.bsfs.Literal, None))
-        self.l_integer = types.Literal(ns.xsd.integer, types.Literal(ns.bsfs.Literal, None))
-        self.l_unused = types.Literal(ns.xsd.boolean, types.Literal(ns.bsfs.Literal, None))
-        self.literals = [self.l_root, self.l_string, self.l_integer, self.l_unused]
+        self.l_root = types.ROOT_LITERAL
+        self.l_number = types.ROOT_NUMBER
+        self.l_blob = types.ROOT_BLOB
+        self.l_array = types.ROOT_ARRAY
+        self.l_time = types.ROOT_TIME
+        self.l_string = self.l_root.child(ns.xsd.string)
+        self.l_integer = self.l_root.child(ns.xsd.integer)
+        self.l_unused = self.l_root.child(ns.xsd.boolean)
+        self.f_root = types.ROOT_FEATURE
+        self.literals = [self.l_root, self.l_array, self.f_root, self.l_number, self.l_time, self.l_string, self.l_integer, self.l_unused, self.l_blob]
 
         # predicates
-        self.p_root = types.Predicate(ns.bsfs.Predicate, None, types.Node(ns.bsfs.Node, None), None, False)
-        self.p_tag = self.p_root.get_child(ns.bse.tag, self.n_ent, self.n_tag, False)
-        self.p_group = self.p_tag.get_child(ns.bse.group, self.n_img, self.n_tag, False)
-        self.p_comment = self.p_root.get_child(ns.bse.comment, self.n_root, self.l_string, True)
+        self.p_root = types.ROOT_PREDICATE
+        self.p_tag = self.p_root.child(ns.bse.tag, self.n_ent, self.n_tag, False)
+        self.p_group = self.p_tag.child(ns.bse.group, self.n_img, self.n_tag, False)
+        self.p_comment = self.p_root.child(ns.bse.comment, self.n_root, self.l_string, True)
         self.predicates = [self.p_root, self.p_tag, self.p_group, self.p_comment]
 
     def test_construction(self):
+        # no args yields a minimal schema
+        schema = Schema()
+        self.assertSetEqual(set(schema.nodes()), {self.n_root})
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_number, self.l_array, self.l_time, self.f_root, self.l_blob})
+        self.assertSetEqual(set(schema.predicates()), {self.p_root})
+
         # nodes and literals are optional
         schema = Schema(self.predicates)
         self.assertSetEqual(set(schema.nodes()), {self.n_root, self.n_ent, self.n_img, self.n_tag})
-        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string})
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string, self.l_number, self.l_time, self.l_array, self.f_root, self.l_blob})
         self.assertSetEqual(set(schema.predicates()), set(self.predicates))
 
         # predicates, nodes, and literals are respected
@@ -101,19 +111,19 @@ class TestSchema(unittest.TestCase):
 
         # literals are complete
         schema = Schema(self.predicates, self.nodes, None)
-        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string})
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string, self.l_number, self.l_array, self.l_time, self.f_root, self.l_blob})
         schema = Schema(self.predicates, self.nodes, [])
-        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string})
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string, self.l_number, self.l_array, self.l_time, self.f_root, self.l_blob})
         schema = Schema(self.predicates, self.nodes, [self.l_string])
-        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string})
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string, self.l_number, self.l_array, self.l_time, self.f_root, self.l_blob})
         schema = Schema(self.predicates, self.nodes, [self.l_integer])
-        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string, self.l_integer})
+        self.assertSetEqual(set(schema.literals()), {self.l_root, self.l_string, self.l_integer, self.l_number, self.l_array, self.l_time, self.f_root, self.l_blob})
         schema = Schema(self.predicates, self.nodes, [self.l_integer, self.l_unused])
         self.assertSetEqual(set(schema.literals()), set(self.literals))
 
         # predicates are complete
         schema = Schema([], self.nodes, self.literals)
-        self.assertSetEqual(set(schema.predicates()), set())
+        self.assertSetEqual(set(schema.predicates()), {self.p_root})
         schema = Schema([self.p_group], self.nodes, self.literals)
         self.assertSetEqual(set(schema.predicates()), {self.p_root, self.p_tag, self.p_group})
         schema = Schema([self.p_group, self.p_comment], self.nodes, self.literals)
@@ -153,20 +163,27 @@ class TestSchema(unittest.TestCase):
         self.assertRaises(errors.ConsistencyError, Schema,
             {}, {types.Node(ns.bsfs.Foo, None)}, {types.Node(ns.bsfs.Foo, None)})
         self.assertRaises(errors.ConsistencyError, Schema,
-            {types.Predicate(ns.bsfs.Foo, None, types.Node(ns.bsfs.Node, None), None, False)}, {}, {types.Node(ns.bsfs.Foo, None)})
+            {types.Predicate(ns.bsfs.Foo, None, types.Node(ns.bsfs.Node, None), types.ROOT_VERTEX, False)}, {}, {types.Node(ns.bsfs.Foo, None)})
         self.assertRaises(errors.ConsistencyError, Schema,
-            {types.Predicate(ns.bsfs.Foo, None, types.Node(ns.bsfs.Node, None), None, False)}, {types.Node(ns.bsfs.Foo, None)}, {})
+            {types.Predicate(ns.bsfs.Foo, None, types.Node(ns.bsfs.Node, None), types.ROOT_VERTEX, False)}, {types.Node(ns.bsfs.Foo, None)}, {})
         self.assertRaises(errors.ConsistencyError, Schema,
-            {types.Predicate(ns.bsfs.Foo, None, types.Node(ns.bsfs.Node, None), None, False)}, {types.Node(ns.bsfs.Foo, None)}, {types.Node(ns.bsfs.Foo, None)})
+            {types.Predicate(ns.bsfs.Foo, None, types.Node(ns.bsfs.Node, None), types.ROOT_VERTEX, False)}, {types.Node(ns.bsfs.Foo, None)}, {types.Node(ns.bsfs.Foo, None)})
+
 
     def test_str(self):
+        # string conversion
         self.assertEqual(str(Schema([])), 'Schema()')
         self.assertEqual(str(Schema([], [], [])), 'Schema()')
         self.assertEqual(str(Schema(self.predicates, self.nodes, self.literals)), 'Schema()')
-        self.assertEqual(repr(Schema([])), 'Schema([], [], [])')
-        self.assertEqual(repr(Schema([], [], [])), 'Schema([], [], [])')
+        # repr conversion with only default nodes, literals, and predicates
+        n = [ns.bsfs.Node]
+        l = [ns.bsfs.Literal, ns.bsl.Array, ns.bsl.Array.Feature, ns.bsl.BinaryBlob, ns.bsl.Number, ns.bsl.Time]
+        p = [ns.bsfs.Predicate]
+        self.assertEqual(repr(Schema()), f'Schema({n}, {l}, {p})')
+        self.assertEqual(repr(Schema([], [], [])), f'Schema({n}, {l}, {p})')
+        # repr conversion
         n = [ns.bsfs.Entity, ns.bsfs.Image, ns.bsfs.Node, ns.bsfs.Tag, ns.bsfs.Unused]
-        l = [ns.bsfs.Literal, ns.xsd.boolean, ns.xsd.integer, ns.xsd.string]
+        l = [ns.xsd.boolean, ns.xsd.integer, ns.xsd.string, ns.bsfs.Literal, ns.bsl.Array, ns.bsl.Array.Feature, ns.bsl.BinaryBlob, ns.bsl.Number, ns.bsl.Time]
         p = [ns.bse.comment, ns.bse.group, ns.bse.tag, ns.bsfs.Predicate]
         self.assertEqual(repr(Schema(self.predicates, self.nodes, self.literals)), f'Schema({n}, {l}, {p})')
 
@@ -202,16 +219,16 @@ class TestSchema(unittest.TestCase):
         self.assertNotEqual(hash(schema),
             hash(Schema([self.p_group, self.p_tag, self.p_root], self.nodes, self.literals)))
         self.assertNotEqual(schema,
-            Schema(self.predicates + [self.p_root.get_child(ns.bse.filesize, self.n_ent, self.l_integer)], self.nodes, self.literals))
+            Schema(self.predicates + [self.p_root.child(ns.bse.filesize, self.n_ent, self.l_integer)], self.nodes, self.literals))
         self.assertNotEqual(hash(schema),
-            hash(Schema(self.predicates + [self.p_root.get_child(ns.bse.filesize, self.n_ent, self.l_integer)], self.nodes, self.literals)))
+            hash(Schema(self.predicates + [self.p_root.child(ns.bse.filesize, self.n_ent, self.l_integer)], self.nodes, self.literals)))
 
     def test_order(self):
         # setup
         class Foo(): pass
-        p_foo = self.p_root.get_child(ns.bse.foo, self.n_ent, self.l_string, True)
-        p_sub = p_foo.get_child(ns.bse.sub, self.n_ent, self.l_string, True)
-        p_bar = self.p_root.get_child(ns.bse.bar, self.n_ent, self.l_string, True)
+        p_foo = self.p_root.child(ns.bse.foo, self.n_ent, self.l_string, True)
+        p_sub = p_foo.child(ns.bse.sub, self.n_ent, self.l_string, True)
+        p_bar = self.p_root.child(ns.bse.bar, self.n_ent, self.l_string, True)
 
         # can only compare schema to other schema
         # <
@@ -258,11 +275,11 @@ class TestSchema(unittest.TestCase):
         self.assertTrue(operator.lt(Schema({self.p_tag}), Schema({self.p_group})))
         self.assertTrue(operator.le(Schema({self.p_tag}), Schema({self.p_group})))
         # subset considers differences in predicates and literals
-        self.assertTrue(operator.lt(Schema.Empty(), Schema({self.p_comment})))
+        self.assertTrue(operator.lt(Schema(), Schema({self.p_comment})))
         # subset considers differences in predicates, nodes, and literals
-        self.assertTrue(operator.lt(Schema({}), Schema.Empty()))
-        self.assertTrue(operator.lt(Schema({self.p_tag}), Schema.from_string(self.schema_str)))
-        self.assertTrue(operator.le(Schema({self.p_tag}), Schema.from_string(self.schema_str)))
+        self.assertTrue(operator.le(Schema({}), Schema()))
+        self.assertTrue(operator.lt(Schema({self.p_tag}), from_string(self.schema_str)))
+        self.assertTrue(operator.le(Schema({self.p_tag}), from_string(self.schema_str)))
         self.assertFalse(operator.lt(Schema({self.p_comment}), Schema({self.p_tag})))
         self.assertFalse(operator.le(Schema({self.p_comment}), Schema({self.p_tag})))
 
@@ -280,54 +297,54 @@ class TestSchema(unittest.TestCase):
         self.assertTrue(operator.gt(Schema({self.p_group}), Schema({self.p_tag})))
         self.assertTrue(operator.ge(Schema({self.p_group}), Schema({self.p_tag})))
         # superset considers differences in predicates and literals
-        self.assertTrue(operator.gt(Schema({self.p_comment}), Schema.Empty()))
+        self.assertTrue(operator.gt(Schema({self.p_comment}), Schema()))
         # superset considers differences in predicates, nodes, and literals
-        self.assertTrue(operator.gt(Schema.Empty(), Schema({})))
-        self.assertTrue(operator.gt(Schema.from_string(self.schema_str), Schema({self.p_tag})))
-        self.assertTrue(operator.ge(Schema.from_string(self.schema_str), Schema({self.p_tag})))
+        self.assertTrue(operator.ge(Schema(), Schema({})))
+        self.assertTrue(operator.gt(from_string(self.schema_str), Schema({self.p_tag})))
+        self.assertTrue(operator.ge(from_string(self.schema_str), Schema({self.p_tag})))
         self.assertFalse(operator.gt(Schema({self.p_tag}), Schema({self.p_comment})))
         self.assertFalse(operator.ge(Schema({self.p_tag}), Schema({self.p_comment})))
 
         # inconsistent schema cannot be a subset
         self.assertFalse(operator.le(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_ent, self.l_integer, True)}))) # inconsistent w.r.t. literal
+            self.p_root.child(ns.bse.foo, self.n_ent, self.l_integer, True)}))) # inconsistent w.r.t. literal
         self.assertFalse(operator.le(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_img, self.l_string, True)}))) # inconsistent w.r.t. node
+            self.p_root.child(ns.bse.foo, self.n_img, self.l_string, True)}))) # inconsistent w.r.t. node
         self.assertFalse(operator.le(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_ent, self.l_string, False)}))) # inconsistent w.r.t. unique
+            self.p_root.child(ns.bse.foo, self.n_ent, self.l_string, False)}))) # inconsistent w.r.t. unique
         self.assertFalse(operator.le(Schema({}, {self.n_img}), Schema({}, {
             types.Node(ns.bsfs.Image, types.Node(ns.bsfs.Node, None))})))
         self.assertFalse(operator.le(Schema({}, {}, {self.l_integer}), Schema({}, {}, {
             types.Literal(ns.xsd.integer, types.Literal(ns.xsd.number, types.Literal(ns.bsfs.Literal, None)))})))
         # inconsistent schema cannot be a true subset
         self.assertFalse(operator.lt(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_ent, self.l_integer, True)}))) # inconsistent w.r.t. literal
+            self.p_root.child(ns.bse.foo, self.n_ent, self.l_integer, True)}))) # inconsistent w.r.t. literal
         self.assertFalse(operator.lt(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_img, self.l_string, True)}))) # inconsistent w.r.t. node
+            self.p_root.child(ns.bse.foo, self.n_img, self.l_string, True)}))) # inconsistent w.r.t. node
         self.assertFalse(operator.lt(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_ent, self.l_string, False)}))) # inconsistent w.r.t. unique
+            self.p_root.child(ns.bse.foo, self.n_ent, self.l_string, False)}))) # inconsistent w.r.t. unique
         self.assertFalse(operator.lt(Schema({}, {self.n_img}), Schema({}, {
             types.Node(ns.bsfs.Image, types.Node(ns.bsfs.Node, None))})))
         self.assertFalse(operator.lt(Schema({}, {}, {self.l_integer}), Schema({}, {}, {
             types.Literal(ns.xsd.integer, types.Literal(ns.xsd.number, types.Literal(ns.bsfs.Literal, None)))})))
         # inconsistent schema cannot be a superset
         self.assertFalse(operator.ge(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_ent, self.l_integer, True)}))) # inconsistent w.r.t. literal
+            self.p_root.child(ns.bse.foo, self.n_ent, self.l_integer, True)}))) # inconsistent w.r.t. literal
         self.assertFalse(operator.ge(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_img, self.l_string, True)}))) # inconsistent w.r.t. node
+            self.p_root.child(ns.bse.foo, self.n_img, self.l_string, True)}))) # inconsistent w.r.t. node
         self.assertFalse(operator.ge(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_ent, self.l_string, False)}))) # inconsistent w.r.t. unique
+            self.p_root.child(ns.bse.foo, self.n_ent, self.l_string, False)}))) # inconsistent w.r.t. unique
         self.assertFalse(operator.ge(Schema({}, {self.n_img}), Schema({}, {
             types.Node(ns.bsfs.Image, types.Node(ns.bsfs.Node, None))})))
         self.assertFalse(operator.ge(Schema({}, {}, {self.l_integer}), Schema({}, {}, {
             types.Literal(ns.xsd.integer, types.Literal(ns.xsd.number, types.Literal(ns.bsfs.Literal, None)))})))
         # inconsistent schema cannot be a true superset
         self.assertFalse(operator.gt(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_ent, self.l_integer, True)}))) # inconsistent w.r.t. literal
+            self.p_root.child(ns.bse.foo, self.n_ent, self.l_integer, True)}))) # inconsistent w.r.t. literal
         self.assertFalse(operator.gt(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_img, self.l_string, True)}))) # inconsistent w.r.t. node
+            self.p_root.child(ns.bse.foo, self.n_img, self.l_string, True)}))) # inconsistent w.r.t. node
         self.assertFalse(operator.gt(Schema({p_foo}), Schema({
-            self.p_root.get_child(ns.bse.foo, self.n_ent, self.l_string, False)}))) # inconsistent w.r.t. unique
+            self.p_root.child(ns.bse.foo, self.n_ent, self.l_string, False)}))) # inconsistent w.r.t. unique
         self.assertFalse(operator.gt(Schema({}, {self.n_img}), Schema({}, {
             types.Node(ns.bsfs.Image, types.Node(ns.bsfs.Node, None))})))
         self.assertFalse(operator.gt(Schema({}, {}, {self.l_integer}), Schema({}, {}, {
@@ -351,26 +368,26 @@ class TestSchema(unittest.TestCase):
         # difference does not contain predicates from the RHS
         diff = Schema({self.p_tag, self.p_comment}).diff(Schema({self.p_group}))
         self.assertSetEqual(set(diff.nodes), set())
-        self.assertSetEqual(set(diff.literals), {self.l_root, self.l_string})
+        self.assertSetEqual(set(diff.literals), {self.l_string})
         self.assertSetEqual(set(diff.predicates), {self.p_comment})
 
         # difference considers extra nodes and literals
         diff = Schema({self.p_tag}, {self.n_unused}, {self.l_unused}).diff(Schema({self.p_tag}))
         self.assertSetEqual(set(diff.nodes), {self.n_unused})
-        self.assertSetEqual(set(diff.literals), {self.l_root, self.l_unused})
+        self.assertSetEqual(set(diff.literals), {self.l_unused})
         self.assertSetEqual(set(diff.predicates), set())
 
         # difference considers inconsistent types
         diff = Schema({self.p_tag}, {self.n_unused}, {self.l_unused}).diff(
             Schema({self.p_tag}, {types.Node(ns.bsfs.Unused, None)}, {types.Literal(ns.xsd.boolean, None)}))
         self.assertSetEqual(set(diff.nodes), {self.n_unused})
-        self.assertSetEqual(set(diff.literals), {self.l_root, self.l_unused})
+        self.assertSetEqual(set(diff.literals), {self.l_unused})
         self.assertSetEqual(set(diff.predicates), set())
 
         # __sub__ is an alias for diff
         diff = Schema({self.p_comment}, {self.n_unused}, {self.l_unused}) - Schema({self.p_group})
         self.assertSetEqual(set(diff.nodes), {self.n_unused})
-        self.assertSetEqual(set(diff.literals), {self.l_root, self.l_string, self.l_unused})
+        self.assertSetEqual(set(diff.literals), {self.l_string, self.l_unused})
         self.assertSetEqual(set(diff.predicates), {self.p_comment})
         # __sub__ only accepts Schema instances
         class Foo(): pass
@@ -547,196 +564,6 @@ class TestSchema(unittest.TestCase):
         self.assertFalse(schema.has_predicate(ns.bse.mimetype))
         self.assertFalse(schema.has_predicate(self.p_root))
 
-    def test_empty(self):
-        self.assertEqual(Schema.Empty(), Schema(
-            [types.Predicate(ns.bsfs.Predicate, None, types.Node(ns.bsfs.Node, None), None, False)],
-            [types.Node(ns.bsfs.Node, None)],
-            [types.Literal(ns.bsfs.Literal, None)],
-            ))
-
-    def test_from_string(self):
-        # from_string creates a schema
-        self.assertEqual(
-            Schema(self.predicates, self.nodes, self.literals),
-            Schema.from_string(self.schema_str))
-
-        # schema contains at least the root types
-        self.assertEqual(Schema.from_string(''), Schema({self.p_root}, {self.n_root}, {self.l_root}))
-
-        # custom example
-        self.assertEqual(
-            Schema({types.Predicate(ns.bsfs.Predicate, None, self.n_root, None, False).get_child(
-                ns.bse.filename, self.n_ent, self.l_string, False)}),
-            Schema.from_string('''
-                prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-                prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-                prefix bsfs: <http://bsfs.ai/schema/>
-                prefix bse: <http://bsfs.ai/schema/Entity#>
-
-                bsfs:Entity rdfs:subClassOf bsfs:Node .
-                xsd:string rdfs:subClassOf bsfs:Literal .
-
-                bse:filename rdfs:subClassOf bsfs:Predicate ;
-                    rdfs:domain bsfs:Entity ;
-                    rdfs:range xsd:string ;
-                    bsfs:unique "false"^^xsd:boolean .
-                '''))
-
-        # all nodes must be defined
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-            prefix bse: <http://bsfs.ai/schema/Entity#>
-
-            xsd:string rdfs:subClassOf bsfs:Literal .
-
-            bse:filename rdfs:subClassOf bsfs:Predicate ;
-                rdfs:domain bsfs:Entity ;
-                rdfs:range xsd:string ;
-                bsfs:unique "false"^^xsd:boolean .
-            ''')
-
-        # all literals must be defined
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-            prefix bse: <http://bsfs.ai/schema/Entity#>
-
-            bsfs:Entity rdfs:subClassOf bsfs:Node .
-
-            bse:filename rdfs:subClassOf bsfs:Predicate ;
-                rdfs:domain bsfs:Entity ;
-                rdfs:range xsd:string ;
-                bsfs:unique "false"^^xsd:boolean .
-            ''')
-
-        # must not have circular dependencies
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-            bsfs:Entity rdfs:subClassOf bsfs:Node .
-            # ah, a nice circular dependency
-            bsfs:Entity rdfs:subClassOf bsfs:Document .
-            bsfs:Document rdfs:subClassOf bsfs:Entity .
-            bsfs:PDF rdfs:subClassOf bsfs:Document .
-            ''')
-
-        # range must be a node or literal
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-            prefix bse: <http://bsfs.ai/schema/Entity#>
-
-            bsfs:Entity rdfs:subClassOf bsfs:Node .
-
-            bse:filename rdfs:subClassOf bsfs:Predicate ;
-                rdfs:domain bsfs:Entity ;
-                rdfs:range xsd:string ;
-                bsfs:unique "false"^^xsd:boolean .
-            ''')
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-            prefix bse: <http://bsfs.ai/schema/Entity#>
-
-            bsfs:Entity rdfs:subClassOf bsfs:Node .
-
-            bse:filename rdfs:subClassOf bsfs:Predicate ;
-                rdfs:domain bsfs:Entity ;
-                rdfs:range bsfs:Foo ;
-                bsfs:unique "false"^^xsd:boolean .
-            ''')
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-            prefix bse: <http://bsfs.ai/schema/Entity#>
-
-            bsfs:Entity rdfs:subClassOf bsfs:Node .
-
-            bse:filename rdfs:subClassOf bsfs:Predicate ;
-                rdfs:domain bsfs:Entity ;
-                rdfs:range bsfs:Predicate ;
-                bsfs:unique "false"^^xsd:boolean .
-            ''')
-
-        # must be consistent
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-
-            bsfs:Entity rdfs:subClassOf bsfs:Node .
-            bsfs:Document rdfs:subClassOf bsfs:Node .
-            bsfs:Document rdfs:subClassOf bsfs:Entity.
-            ''')
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-
-            xsd:string rdfs:subClassOf bsfs:Literal .
-            xsd:name rdfs:subClassOf bsfs:Literal .
-            xsd:name rdfs:subClassOf xsd:string .
-            ''')
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-            prefix bse: <http://bsfs.ai/schema/Entity#>
-
-            bsfs:Entity rdfs:subClassOf bsfs:Node .
-
-            bse:foo rdfs:subClassOf bsfs:Predicate ;
-                rdfs:domain bsfs:Node ;
-                rdfs:range bsfs:Node ;
-                bsfs:unique "false"^^xsd:boolean .
-
-            bse:foo rdfs:subClassOf bsfs:Predicate ;
-                rdfs:domain bsfs:Entity .
-
-            ''')
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-            prefix bse: <http://bsfs.ai/schema/Entity#>
-
-            bsfs:Entity rdfs:subClassOf bsfs:Node .
-
-            bse:foo rdfs:subClassOf bsfs:Predicate ;
-                rdfs:domain bsfs:Node ;
-                rdfs:range bsfs:Node ;
-                bsfs:unique "false"^^xsd:boolean .
-
-            bse:foo rdfs:subClassOf bsfs:Predicate ;
-                rdfs:range bsfs:Entity .
-
-            ''')
-        self.assertRaises(errors.ConsistencyError, Schema.from_string, '''
-            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
-            prefix bsfs: <http://bsfs.ai/schema/>
-            prefix bse: <http://bsfs.ai/schema/Entity#>
-
-            bsfs:Entity rdfs:subClassOf bsfs:Node .
-
-            bse:foo rdfs:subClassOf bsfs:Predicate ;
-                rdfs:domain bsfs:Node ;
-                rdfs:range bsfs:Node ;
-                bsfs:unique "false"^^xsd:boolean .
-
-            bse:foo rdfs:subClassOf bsfs:Predicate ;
-                bsfs:unique "true"^^xsd:boolean .
-
-            ''')
-
-
-
 ## main ##
 
 if __name__ == '__main__':