Added tests to range sets for uncovered parts

runfalk · Dec 22, 2015 · 8cf6f4a · 8cf6f4a
1 parent d751290
commit 8cf6f4a
Show file tree

Hide file tree

Showing 2 changed files with 70 additions and 0 deletions.
diff --git a/spans/settypes.py b/spans/settypes.py
@@ -247,6 +247,7 @@ def contains(self, item):
 
         .. versionadded:: 0.2.0
         """
+
         for r in self._list:
             if r.contains(item) is True:
                 return True
@@ -326,6 +327,8 @@ def remove(self, item):
         :param item: Range to remove from this set.
         """
 
+        self._test_type(item)
+
         # If the list currently only have an empty range do nothing
         if not self:
             return

diff --git a/spans/tests/test_settypes.py b/spans/tests/test_settypes.py
@@ -35,6 +35,9 @@ def test_add(self):
 
         self.assertEqual(list(rset), [intrange(1, 15)])
 
+        with self.assertRaises(TypeError):
+            rset.add(floatrange(1.0))
+
     def test_remove(self):
         rset = intrangeset([intrange(upper=1), intrange(5)])
         rset.remove(intrange(10, 15))
@@ -43,6 +46,23 @@ def test_remove(self):
             rset,
             intrangeset([intrange(upper=1), intrange(5, 10), intrange(15)]))
 
+        # Test deletion of empty set
+        temp = rset.copy()
+        temp.remove(intrange.empty())
+        self.assertEqual(rset, temp)
+
+        # Test total deletion
+        rset.remove(intrange())
+        self.assertEqual(rset, intrangeset([]))
+
+        # Test deletion on empty set
+        temp = intrangeset([])
+        temp.remove(intrange(1, 5))
+        self.assertEqual(temp, intrangeset([]))
+
+        with self.assertRaises(TypeError):
+            rset.remove(floatrange(1.0))
+
     def test_invert(self):
         rset = intrangeset([intrange(1, 5), intrange(10, 15)])
         rset_inv = intrangeset([intrange(upper=1), intrange(5, 10), intrange(15)])
@@ -56,12 +76,18 @@ def test_union(self):
                 intrangeset([intrange(5, 10), intrange(20, 100)]))),
             [intrange(1, 10), intrange(20, 100)])
 
+        with self.assertRaises(TypeError):
+            intrangeset().union(intrange())
+
     def test_difference(self):
         self.assertEqual(
             list(intrangeset([intrange(1, 5), intrange(20, 30)]).difference(
                 intrangeset([intrange(5, 10), intrange(20, 100)]))),
             [intrange(1, 5)])
 
+        with self.assertRaises(TypeError):
+            intrangeset().difference(intrange())
+
     def test_intersection(self):
         self.assertEqual(
             list(intrangeset([intrange(1, 5), intrange(20, 30)]).intersection(
@@ -71,12 +97,53 @@ def test_intersection(self):
             intrangeset([intrange(1, 5)]).intersection(
                 intrangeset([intrange(5, 10)])))
 
+        with self.assertRaises(TypeError):
+            intrangeset().intersection(intrange())
+
     def test_values(self):
         self.assertEqual(
             list(intrangeset([intrange(1, 5), intrange(10, 15)]).values()),
             list(range(1, 5)) + list(range(10, 15)))
 
+    def test_repr(self):
+        self.assertEqual(repr(intrangeset([])), "intrangeset([])")
+        self.assertEqual(
+            repr(intrangeset([intrange(1)])), "intrangeset([intrange([1,))])")
+
     def test_pickling(self):
         range = intrangeset([intrange(1, 10), intrange(20, 30)])
 
         self.assertEqual(range, pickle.loads(pickle.dumps(range)))
+
+    def test_equal(self):
+        range_a = intrange(1, 5)
+        range_b = intrange(10, 15)
+
+        self.assertTrue(
+            intrangeset([range_a, range_b]) == intrangeset([range_a, range_b]))
+        self.assertFalse(
+            intrangeset([range_a, range_b]) == intrangeset([range_a]))
+
+    def test_less_than(self):
+        range_a = intrange(1, 5)
+        range_b = intrange(10, 15)
+
+        self.assertFalse(
+            intrangeset([range_a, range_b]) < intrangeset([range_a]))
+        self.assertTrue(
+            intrangeset([range_a, range_b]) < intrangeset([range_b]))
+        self.assertFalse(
+            intrangeset([range_a, range_b]) <= intrangeset([range_a]))
+
+    def test_greater_than(self):
+        range_a = intrange(1, 5)
+        range_b = intrange(10, 15)
+
+        self.assertTrue(
+            intrangeset([range_a, range_b]) > intrangeset([range_a]))
+        self.assertFalse(
+            intrangeset([range_a, range_b]) > intrangeset([range_b]))
+        self.assertTrue(
+            intrangeset([range_b]) > intrangeset([range_a, range_b]))
+        self.assertTrue(
+            intrangeset([range_a, range_b]) >= intrangeset([range_a]))