schema ordering

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}))