def test_end_overlapping_positive(self):
myset = NumericSet()
myset.add(Interval(1, 2, is_end_inclusive=True)) # (1, 2]
myset.add(Interval(2, 3)) # (2, 3)
self.assertEqual(len(myset.intervals), 1)
self.assertEqual(myset.intervals[0].get_formatted(), '(1, 3)')
def test_ordinary(self):
myset_1 = NumericSet()
myset_1.add(Interval(2, 4, True, True)) # [2, 4]
myset_1.add(Interval(5, 7)) # (5, 7)
myset_1.add(Interval(8, 10, is_end_inclusive=True)) # (8, 10]
myset_2 = NumericSet()
myset_2.add(Interval(2, 5)) # (2, 5)
myset_2.add(Interval(6, 9)) # (6, 9)
union = myset_1.union(myset_2) # [2, 5) + (5, 10]
self.assertEqual(len(union.intervals), 2)
self.assertEqual(union.intervals[0].start, 2)
self.assertEqual(union.intervals[0].end, 5)
self.assertTrue(union.intervals[0].is_start_inclusive)
self.assertFalse(union.intervals[0].is_end_inclusive)
self.assertEqual(union.intervals[1].start, 5)
self.assertEqual(union.intervals[1].end, 10)
self.assertFalse(union.intervals[1].is_start_inclusive)
self.assertTrue(union.intervals[1].is_end_inclusive)
def test_separate(self):
interval_1 = Interval(2, 3, is_start_inclusive=True) # [2, 3)
interval_2 = Interval(0, 1) # (0, 1)
union = Interval.union(interval_1, interval_2) # Two intervals
self.assertEqual(len(union.intervals), 2)
def test_empty(self):
interval_1 = Interval(1, 3, is_start_inclusive=True) # [1, 3)
interval_2 = Interval(0, 1) # (0, 1)
intersection = Interval.intersection(interval_1, interval_2) # Empty
self.assertEqual(intersection, None)
def test_ordinary(self):
myset_1 = NumericSet()
myset_1.add(Interval(2, 4, is_end_inclusive=True)) # (2, 4]
myset_1.add(Interval(5, 7)) # (5, 7)
myset_1.add(Interval(8, 10, is_end_inclusive=True)) # (8, 10]
myset_2 = NumericSet()
myset_2.add(Interval(2, 5)) # (2, 5)
myset_2.add(Interval(6, 9)) # (6, 9)
intersection = myset_1.intersection(
myset_2) # (2, 4] + (6, 7) + (8, 9)
self.assertEqual(len(intersection.intervals), 3)
self.assertEqual(intersection.intervals[0].start, 2)
self.assertEqual(intersection.intervals[0].end, 4)
self.assertFalse(intersection.intervals[0].is_start_inclusive)
self.assertTrue(intersection.intervals[0].is_end_inclusive)
self.assertEqual(intersection.intervals[1].start, 6)
self.assertEqual(intersection.intervals[1].end, 7)
self.assertFalse(intersection.intervals[1].is_start_inclusive)
self.assertFalse(intersection.intervals[1].is_end_inclusive)
self.assertEqual(intersection.intervals[2].start, 8)
self.assertEqual(intersection.intervals[2].end, 9)
self.assertFalse(intersection.intervals[2].is_start_inclusive)
self.assertFalse(intersection.intervals[2].is_end_inclusive)
def test_points(self):
myset_1 = NumericSet()
myset_1.add(Interval(2, 4, True))
myset_1.add(Interval(5, 7))
myset_1.add(Interval(8, 10, is_end_inclusive=True))
myset_2 = NumericSet()
myset_2.add(Interval(2, 5))
myset_2.add(Interval(5, 10))
difference = myset_1.difference(myset_2) # {2} + {10}
self.assertEqual(len(difference.intervals), 2)
self.assertEqual(difference.intervals[0].start, 2)
self.assertEqual(difference.intervals[0].end, 2)
self.assertTrue(difference.intervals[0].is_start_inclusive)
self.assertTrue(difference.intervals[0].is_end_inclusive)
self.assertEqual(difference.intervals[1].start, 10)
self.assertEqual(difference.intervals[1].end, 10)
self.assertTrue(difference.intervals[1].is_start_inclusive)
self.assertTrue(difference.intervals[1].is_end_inclusive)
def test_ordinary(self):
myset_1 = NumericSet()
myset_1.add(Interval(2, 4))
myset_1.add(Interval(5, 7))
myset_1.add(Interval(8, 10))
myset_2 = NumericSet()
myset_2.add(Interval(3, 5))
myset_2.add(Interval(6, 8))
difference = myset_1.difference(myset_2) # (2, 3] + (5, 6] + (8, 10)
self.assertEqual(len(difference.intervals), 3)
self.assertEqual(difference.intervals[0].start, 2)
self.assertEqual(difference.intervals[0].end, 3)
self.assertFalse(difference.intervals[0].is_start_inclusive)
self.assertTrue(difference.intervals[0].is_end_inclusive)
self.assertEqual(difference.intervals[1].start, 5)
self.assertEqual(difference.intervals[1].end, 6)
self.assertFalse(difference.intervals[1].is_start_inclusive)
self.assertTrue(difference.intervals[1].is_end_inclusive)
self.assertEqual(difference.intervals[2].start, 8)
self.assertEqual(difference.intervals[2].end, 10)
self.assertFalse(difference.intervals[2].is_start_inclusive)
self.assertFalse(difference.intervals[2].is_end_inclusive)
def test_empty(self):
myset = NumericSet()
myset.add(Interval(1, 2)) # (1, 2)
myset.add(Interval(2, 3)) # (2, 3)
right_intervals = myset.get_right_intervals(Interval(1.5, 2.5))
self.assertEqual(len(right_intervals), 0)
def test_ordinary(self):
interval = Interval(2, 3, is_end_inclusive=True)
copy = interval.copy()
self.assertEqual(interval.start, copy.start)
self.assertEqual(interval.end, copy.end)
self.assertEqual(interval.is_start_inclusive, copy.is_start_inclusive)
self.assertEqual(interval.is_end_inclusive, copy.is_end_inclusive)
def test_end_overlapping_negative(self):
myset = NumericSet()
myset.add(Interval(1, 2)) # (1, 2)
myset.add(Interval(2, 3)) # (2, 3)
self.assertEqual(len(myset.intervals), 2)
self.assertEqual(myset.intervals[0].get_formatted(), '(1, 2)')
self.assertEqual(myset.intervals[1].get_formatted(), '(2, 3)')
def test_ordinary(self):
myset = NumericSet()
myset.add(Interval(1, 2))
myset.add(Interval(2, 3))
myset.clear()
self.assertEqual(len(myset.intervals), 0)
def test_ordinary(self):
myset = NumericSet()
myset.add(Interval(1, 2)) # (1, 2)
myset.add(Interval(2, 3)) # (2, 3)
myset.add(Interval(4, 5)) # (4, 5)
right_intervals = myset.get_right_intervals(Interval(3, 4))
self.assertEqual(len(right_intervals), 1)
def test_unoverlapping(self):
interval_1 = Interval(1, 3) # (1, 3)
interval_2 = Interval(4, 5) # (4, 5)
difference = Interval.difference(interval_1, interval_2) # (1, 3)
self.assertEqual(difference.start, 1)
self.assertEqual(difference.end, 3)
self.assertFalse(difference.is_start_inclusive)
self.assertFalse(difference.is_end_inclusive)
def test_single_point(self):
interval_1 = Interval(1, 3, is_start_inclusive=True) # [1, 3)
interval_2 = Interval(0, 1, is_end_inclusive=True) # (0, 1]
intersection = Interval.intersection(interval_1, interval_2) # {1}
self.assertEqual(intersection.start, 1)
self.assertEqual(intersection.end, 1)
self.assertTrue(intersection.is_start_inclusive)
self.assertTrue(intersection.is_end_inclusive)
def test_almost_overlapping(self):
interval_1 = Interval(1, 3, is_end_inclusive=True) # (1, 3]
interval_2 = Interval(0, 1, is_end_inclusive=True) # (0, 1]
union = Interval.union(interval_1, interval_2) # (0, 3]
self.assertEqual(len(union.intervals), 1)
self.assertEqual(union.intervals[0].start, 0)
self.assertEqual(union.intervals[0].end, 3)
self.assertFalse(union.intervals[0].is_start_inclusive)
self.assertTrue(union.intervals[0].is_end_inclusive)
def test_right_touch(self):
interval_1 = Interval(0, 1, True, True) # [0, 1]
interval_2 = Interval(1, 3, is_start_inclusive=True) # [1, 3)
difference = Interval.difference(interval_1, interval_2) # [0, 1)
self.assertEqual(len(difference.intervals), 1)
self.assertEqual(difference.intervals[0].start, 0)
self.assertEqual(difference.intervals[0].end, 1)
self.assertTrue(difference.intervals[0].is_start_inclusive)
self.assertFalse(difference.intervals[0].is_end_inclusive)
def test_right_overlap(self):
interval_1 = Interval(0, 2) # (0, 2)
interval_2 = Interval(1, 3) # (1, 3)
difference = Interval.difference(interval_1, interval_2) # (0, 1]
self.assertEqual(len(difference.intervals), 1)
self.assertEqual(difference.intervals[0].start, 0)
self.assertEqual(difference.intervals[0].end, 1)
self.assertFalse(difference.intervals[0].is_start_inclusive)
self.assertTrue(difference.intervals[0].is_end_inclusive)
def test_ordinary(self):
myset = NumericSet()
myset.add(Interval(1, 2))
myset.add(Interval(2, 3))
copy = myset.copy()
self.assertEqual(copy.intervals[0].get_formatted(),
myset.intervals[0].get_formatted())
self.assertEqual(copy.intervals[1].get_formatted(),
myset.intervals[1].get_formatted())
def test_ordinary(self):
interval_1 = Interval(1, 3, is_end_inclusive=True) # (1, 3]
interval_2 = Interval(2, 5) # (2, 5)
intersection = Interval.intersection(interval_1, interval_2) # (2, 3]
self.assertEqual(intersection.start, 2)
self.assertEqual(intersection.end, 3)
self.assertFalse(intersection.is_start_inclusive)
self.assertTrue(intersection.is_end_inclusive)
def test_overlapping(self):
interval_1 = Interval(1, 3, is_end_inclusive=True) # (1, 3]
interval_2 = Interval(2, 5) # (2, 5)
union = Interval.union(interval_1, interval_2) # (1, 5)
self.assertEqual(len(union.intervals), 1)
self.assertEqual(union.intervals[0].start, 1)
self.assertEqual(union.intervals[0].end, 5)
self.assertFalse(union.intervals[0].is_start_inclusive)
self.assertFalse(union.intervals[0].is_end_inclusive)
def test_ordinary_positive(self):
myset_1 = NumericSet()
myset_1.add(Interval(2, 4, is_end_inclusive=True)) # (2, 4]
myset_1.add(Interval(5, 7, True)) # [5, 7)
myset_1.add(Interval(8, 10, is_end_inclusive=True)) # (8, 10]
myset_2 = NumericSet()
myset_2.add(Interval(2, 10, is_end_inclusive=True)) # (2, 10]
self.assertFalse(myset_1.issuperset(myset_2))
self.assertTrue(myset_2.issuperset(myset_1))
def test_ordinary(self):
myset = NumericSet()
interval = Interval(2, 4)
myset.add(interval)
self.assertEqual(myset.pop(), interval)
def test_split(self):
interval_1 = Interval(0, 4, True, True) # [0, 4]
interval_2 = Interval(2, 3, is_start_inclusive=True) # [2, 3)
difference = Interval.difference(interval_1,
interval_2) # [0, 2) + [3, 4]
self.assertEqual(len(difference.intervals), 2)
self.assertEqual(difference.intervals[0].start, 0)
self.assertEqual(difference.intervals[0].end, 2)
self.assertTrue(difference.intervals[0].is_start_inclusive)
self.assertFalse(difference.intervals[0].is_end_inclusive)
self.assertEqual(difference.intervals[1].start, 3)
self.assertEqual(difference.intervals[1].end, 4)
self.assertTrue(difference.intervals[1].is_start_inclusive)
self.assertTrue(difference.intervals[1].is_end_inclusive)
def test_points(self):
myset_1 = NumericSet()
myset_1.add(Interval(2, 4, is_end_inclusive=True)) # (2, 4]
myset_1.add(Interval(5, 7, True)) # [5, 7)
myset_1.add(Interval(8, 10, is_end_inclusive=True)) # (8, 10]
myset_2 = NumericSet()
myset_2.add(Interval(4, 5, True)) # [4, 5)
myset_2.add(Interval(7, 8)) # (7, 8)
intersection = myset_1.intersection(myset_2) # {4}
self.assertEqual(len(intersection.intervals), 1)
self.assertEqual(intersection.intervals[0].start, 4)
self.assertEqual(intersection.intervals[0].end, 4)
self.assertTrue(intersection.intervals[0].is_start_inclusive)
self.assertTrue(intersection.intervals[0].is_end_inclusive)
def test_ordinary(self):
myset_1 = NumericSet()
myset_1.add(Interval(2, 4, True, True)) # [2, 4]
myset_1.add(Interval(5, 7)) # (5, 7)
myset_1.add(Interval(8, 10, is_end_inclusive=True)) # (8, 10]
myset_2 = NumericSet()
myset_2.add(Interval(2, 5)) # (2, 5)
myset_2.add(Interval(6, 9)) # (6, 9)
symmetric_diff = myset_1.symmetric_difference(
myset_2) # {2} + (4, 5) + [7, 8] + [9, 10]
self.assertEqual(len(symmetric_diff.intervals), 5)
self.assertEqual(symmetric_diff.intervals[0].start, 2)
self.assertEqual(symmetric_diff.intervals[0].end, 2)
self.assertTrue(symmetric_diff.intervals[0].is_start_inclusive)
self.assertTrue(symmetric_diff.intervals[0].is_end_inclusive)
self.assertEqual(symmetric_diff.intervals[1].start, 4)
self.assertEqual(symmetric_diff.intervals[1].end, 5)
self.assertFalse(symmetric_diff.intervals[1].is_start_inclusive)
self.assertFalse(symmetric_diff.intervals[1].is_end_inclusive)
self.assertEqual(symmetric_diff.intervals[2].start, 5)
self.assertEqual(symmetric_diff.intervals[2].end, 6)
self.assertFalse(symmetric_diff.intervals[2].is_start_inclusive)
self.assertTrue(symmetric_diff.intervals[2].is_end_inclusive)
self.assertEqual(symmetric_diff.intervals[3].start, 7)
self.assertEqual(symmetric_diff.intervals[3].end, 8)
self.assertTrue(symmetric_diff.intervals[3].is_start_inclusive)
self.assertTrue(symmetric_diff.intervals[3].is_end_inclusive)
self.assertEqual(symmetric_diff.intervals[4].start, 9)
self.assertEqual(symmetric_diff.intervals[4].end, 10)
self.assertTrue(symmetric_diff.intervals[4].is_start_inclusive)
self.assertTrue(symmetric_diff.intervals[4].is_end_inclusive)
def test_regular(self):
myset = NumericSet()
myset.add(Interval(2, 3)) # (2, 3)
myset.add(Interval(13, 15)) # (13, 15)
myset.add(Interval(9, 10)) # (9, 10)
myset.add(Interval(6, 8)) # (6, 8)
myset.add(Interval(0, 1)) # (0, 1)
myset.add(Interval(2.5, 8.5, is_end_inclusive=True)) # (2.5, 8.5]
# result: (0, 1) (2, 8.5] (9, 10) (13, 15)
self.assertEqual(len(myset.intervals), 4)
self.assertEqual(myset.intervals[0].get_formatted(), '(0, 1)')
self.assertEqual(myset.intervals[1].get_formatted(), '(2, 8.5]')
self.assertEqual(myset.intervals[2].get_formatted(), '(9, 10)')
self.assertEqual(myset.intervals[3].get_formatted(), '(13, 15)')
def test_ordinary(self):
myset = NumericSet()
myset.add(Interval(2, 3))
myset.add(Interval(4, 5))
myset.add(Interval(6, 7))
myset.add(Interval(8, 9))
myset.add(Interval(10, 11))
myset.add(Interval(12, 13))
myset.remove(Interval(2.5, 12.5))
self.assertEqual(len(myset.intervals), 2)
self.assertEqual(myset.intervals[0].start, 2)
self.assertEqual(myset.intervals[0].end, 2.5)
self.assertFalse(myset.intervals[0].is_start_inclusive)
self.assertTrue(myset.intervals[0].is_end_inclusive)
self.assertEqual(myset.intervals[1].start, 12.5)
self.assertEqual(myset.intervals[1].end, 13)
self.assertTrue(myset.intervals[1].is_start_inclusive)
self.assertFalse(myset.intervals[1].is_end_inclusive)
def test_end_positive(self):
interval = Interval(1, 3, is_end_inclusive=True)
self.assertTrue(interval.includes(3))
def test_end_negative(self):
interval = Interval(1, 3)
self.assertFalse(interval.includes(3))
def test_start_positive(self):
interval = Interval(1, 3, is_start_inclusive=True)
self.assertTrue(interval.includes(1))
