schema type comparison across classes

1 files changed, 17 insertions, 16 deletions

diff --git a/test/schema/test_types.py b/test/schema/test_types.py
index 26da270..1eeafa1 100644
--- a/test/schema/test_types.py
+++ b/test/schema/test_types.py
@@ -140,30 +140,31 @@ class TestType(unittest.TestCase):
         self.assertFalse(bike >= bicycle)
         self.assertFalse(bike == bicycle)
 
-        # can compare types along the class hierarchy
+        # comparing different classes returns False ...
+        # ... when classes are hierarchically related
         class Foo(_Type): pass
         foo = Foo('Foo', bike)
-        self.assertTrue(foo < bike)
-        self.assertTrue(foo <= bike)
+        self.assertFalse(foo < bike)
+        self.assertFalse(foo <= bike)
         self.assertFalse(foo > bike)
         self.assertFalse(foo >= bike)
         # goes both ways
         self.assertFalse(bike < foo)
         self.assertFalse(bike <= foo)
-        self.assertTrue(bike > foo)
-        self.assertTrue(bike >= foo)
-        # cannot compare unrelated classes
+        self.assertFalse(bike > foo)
+        self.assertFalse(bike >= foo)
+        # ... when classes are unrelated
         class Bar(_Type): pass
         bar = Bar('Bar', bike)
-        self.assertRaises(TypeError, operator.lt, foo, bar)
-        self.assertRaises(TypeError, operator.le, foo, bar)
-        self.assertRaises(TypeError, operator.gt, foo, bar)
-        self.assertRaises(TypeError, operator.ge, foo, bar)
+        self.assertFalse(foo < bar)
+        self.assertFalse(foo <= bar)
+        self.assertFalse(foo > bar)
+        self.assertFalse(foo >= bar)
         # goes both ways
-        self.assertRaises(TypeError, operator.lt, bar, foo)
-        self.assertRaises(TypeError, operator.le, bar, foo)
-        self.assertRaises(TypeError, operator.gt, bar, foo)
-        self.assertRaises(TypeError, operator.ge, bar, foo)
+        self.assertFalse(bar < foo)
+        self.assertFalse(bar <= foo)
+        self.assertFalse(bar > foo)
+        self.assertFalse(bar >= foo)
 
 
 class TestPredicate(unittest.TestCase):
@@ -262,7 +263,7 @@ class TestPredicate(unittest.TestCase):
         # range must be subtype of parent's range
         self.assertRaises(errors.ConsistencyError, tag.child, ns.bse.foo, range=n_root)
         self.assertRaises(errors.ConsistencyError, tag.child, ns.bse.foo, range=Node(ns.bsfs.Image, n_root))
-        self.assertRaises(TypeError, tag.child, ns.bse.foo, range=Literal(ns.bsfs.Tag, l_root))
+        self.assertRaises(errors.ConsistencyError, tag.child, ns.bse.foo, range=Literal(ns.bsfs.Tag, l_root))
         # range can be subtyped from ROOT_VERTEX to Node or Literal
         self.assertEqual(n_root, root.child(ns.bse.foo, range=n_root).range)
         self.assertEqual(l_root, root.child(ns.bse.foo, range=l_root).range)
@@ -370,7 +371,7 @@ class TestFeature(unittest.TestCase):
         # range must be subtype of parent's range
         self.assertRaises(errors.ConsistencyError, colors.child, ns.bse.foo, range=Literal(ns.bsfs.Literal, None))
         self.assertRaises(errors.ConsistencyError, colors.child, ns.bse.foo, range=Literal(ns.bsfs.foo, Literal(ns.bsfs.Literal, None)))
-        self.assertRaises(TypeError, colors.child, ns.bse.foo, range=Node(ns.bsfs.Tag, n_root))
+        self.assertRaises(errors.ConsistencyError, colors.child, ns.bse.foo, range=Node(ns.bsfs.Tag, n_root))
 
 
 ## main ##