aboutsummaryrefslogtreecommitdiffstats
path: root/test/schema
diff options
context:
space:
mode:
Diffstat (limited to 'test/schema')
-rw-r--r--test/schema/test_schema.py129
1 files changed, 129 insertions, 0 deletions
diff --git a/test/schema/test_schema.py b/test/schema/test_schema.py
index 2dc26e8..888cdca 100644
--- a/test/schema/test_schema.py
+++ b/test/schema/test_schema.py
@@ -206,6 +206,135 @@ class TestSchema(unittest.TestCase):
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)))
+ 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)
+
+ # can only compare schema to other schema
+ # <
+ self.assertRaises(TypeError, operator.lt, Schema({p_foo, p_bar}), 'hello world')
+ self.assertRaises(TypeError, operator.lt, Schema({p_foo, p_bar}), 1234)
+ self.assertRaises(TypeError, operator.lt, Schema({p_foo, p_bar}), p_foo)
+ self.assertRaises(TypeError, operator.lt, Schema({p_foo, p_bar}), Foo())
+ # <=
+ self.assertRaises(TypeError, operator.le, Schema({p_foo, p_bar}), 'hello world')
+ self.assertRaises(TypeError, operator.le, Schema({p_foo, p_bar}), 1234)
+ self.assertRaises(TypeError, operator.le, Schema({p_foo, p_bar}), p_foo)
+ self.assertRaises(TypeError, operator.le, Schema({p_foo, p_bar}), Foo())
+ # >
+ self.assertRaises(TypeError, operator.gt, Schema({p_foo, p_bar}), 'hello world')
+ self.assertRaises(TypeError, operator.gt, Schema({p_foo, p_bar}), 1234)
+ self.assertRaises(TypeError, operator.gt, Schema({p_foo, p_bar}), p_foo)
+ self.assertRaises(TypeError, operator.gt, Schema({p_foo, p_bar}), Foo())
+ # >=
+ self.assertRaises(TypeError, operator.ge, Schema({p_foo, p_bar}), 'hello world')
+ self.assertRaises(TypeError, operator.ge, Schema({p_foo, p_bar}), 1234)
+ self.assertRaises(TypeError, operator.ge, Schema({p_foo, p_bar}), p_foo)
+ self.assertRaises(TypeError, operator.ge, Schema({p_foo, p_bar}), Foo())
+
+ # a schema is a subset of itself
+ self.assertTrue(operator.le(Schema({self.p_tag}), Schema({self.p_tag})))
+ # a schema is a superset of itself
+ self.assertTrue(operator.ge(Schema({self.p_tag}), Schema({self.p_tag})))
+ # a schema is not a true subset of itself
+ self.assertFalse(operator.lt(Schema({self.p_tag}), Schema({self.p_tag})))
+ # a schema is not a true superset of itself
+ self.assertFalse(operator.gt(Schema({self.p_tag}), Schema({self.p_tag})))
+
+ # subset considers predicates
+ self.assertTrue(operator.lt(Schema({p_foo}), Schema({p_foo, p_bar})))
+ self.assertTrue(operator.lt(Schema({p_foo}), Schema({p_sub})))
+ self.assertFalse(operator.lt(Schema({p_foo}), Schema({p_bar})))
+ # subset considers nodes
+ self.assertTrue(operator.lt(Schema({self.p_tag}), Schema({self.p_tag}, {self.n_unused})))
+ self.assertFalse(operator.lt(Schema({self.p_tag}, {self.n_unused}), Schema({self.p_tag})))
+ # subset considers literals
+ self.assertTrue(operator.lt(Schema({self.p_tag}), Schema({self.p_tag}, {}, {self.l_unused})))
+ self.assertFalse(operator.lt(Schema({self.p_tag}, {}, {self.l_unused}), Schema({self.p_tag})))
+ # subset considers differences in predicates and nodes
+ 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})))
+ # 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.assertFalse(operator.lt(Schema({self.p_comment}), Schema({self.p_tag})))
+ self.assertFalse(operator.le(Schema({self.p_comment}), Schema({self.p_tag})))
+
+ # superset considers predicates
+ self.assertTrue(operator.gt(Schema({p_foo, p_bar}), Schema({p_foo})))
+ self.assertTrue(operator.gt(Schema({p_sub}), Schema({p_foo})))
+ self.assertFalse(operator.gt(Schema({p_foo}), Schema({p_bar})))
+ # superset considers nodes
+ self.assertTrue(operator.gt(Schema({self.p_tag}, {self.n_unused}), Schema({self.p_tag})))
+ self.assertFalse(operator.gt(Schema({self.p_tag}), Schema({self.p_tag}, {self.n_unused})))
+ # superset considers literals
+ self.assertTrue(operator.gt(Schema({self.p_tag}, {}, {self.l_unused}), Schema({self.p_tag})))
+ self.assertFalse(operator.gt(Schema({self.p_tag}), Schema({self.p_tag}, {}, {self.l_unused})))
+ # superset considers differences in predicates and nodes
+ 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()))
+ # 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.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.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.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.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.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.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.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.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.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.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.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.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.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({}, {}, {
+ types.Literal(ns.xsd.integer, types.Literal(ns.xsd.number, types.Literal(ns.bsfs.Literal, None)))})))
+
+
+
def test_diff(self):
# difference can be empty
diff = Schema({self.p_tag}).diff(Schema({self.p_group}))
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-02 22:26:00 +0000