def test_simplify(self):
"""Range reduce should group overlapping ranges"""
#consolidate should have no effect when no overlap
r = self.two
r.simplify()
self.assertEqual(r.Spans, [Span(3, 5), Span(8, 11)])
#should consolidate an overlap of the same direction
r.Spans.append(Span(-1, 4))
r.simplify()
self.assertEqual(r.Spans, [Span(-1, 5), Span(8, 11)])
#should also consolidate _adjacent_ spans of the same direction
r.Spans.append(Span(11, 14))
r.simplify()
self.assertEqual(r.Spans, [Span(-1, 5), Span(8, 14)])
#bridge should cause consolidations
s = Range(r)
s.Spans.append(Span(5, 8))
s.simplify()
self.assertEqual(s.Spans, [Span(-1, 14)])
#ditto for bridge that overlaps everything
s = Range(r)
s.Spans.append(Span(-100, 100))
s.simplify()
self.assertEqual(s.Spans, [Span(-100, 100)])
#however, can't consolidate span in other orientation
s = Range(r)
s.Spans.append(Span(-100, 100, Reverse=True))
self.assertEqual(s.Spans, [Span(-1,5), Span(8,14), \
Span(-100,100,Reverse=True)])
def test_init(self):
self.assertEqual(RangeFromString(''), Range())
self.assertEqual(RangeFromString(' 3 , 4\t, ,, 10 ,'),
Range([3, 4, 10]))
self.assertEqual(RangeFromString('3,4-10,1-5'),
Range([Span(3), Span(4, 10),
Span(1, 5)]))
def test_contains(self):
"""Range contains an item if any span contains it"""
self.assertContains(self.one, 50)
self.assertContains(self.one, 0)
self.assertContains(self.one, 99)
self.assertNotContains(self.one, 100)
self.assertContains(self.three, 6)
self.assertNotContains(self.three, 7)
self.assertNotContains(self.three, 8)
self.assertNotContains(self.three, 14)
self.assertContains(self.three, 15)
self.assertNotContains(self.three, 29)
self.assertContains(self.three, 30)
self.assertContains(self.three, 34)
self.assertNotContains(self.three, 35)
self.assertNotContains(self.three, 40)
#should work if a span is added
self.three.Spans.append(40)
self.assertContains(self.three, 40)
#should work for spans
self.assertContains(self.three, Span(31, 33))
self.assertNotContains(self.three, Span(31, 37))
#span contains itself
self.assertContains(self.two, self.twocopy)
#should work for ranges
self.assertContains(self.three, Range([6, Span(15, 16), Span(30, 33)]))
#should work for copy, except when extra piece added
threecopy = Range(self.three)
self.assertContains(self.three, threecopy)
threecopy.Spans.append(1000)
self.assertNotContains(self.three, threecopy)
self.three.Spans.append(Span(950, 1050))
self.assertContains(self.three, threecopy)
self.assertNotContains(threecopy, self.three)
def test_cmp(self):
"""Ranges should compare equal if they have the same spans"""
self.assertEqual(
self.twothree,
Range([
Span(3, 5),
Span(8, 11),
Span(6, 7),
Span(15, 17),
Span(30, 35)
]))
self.assertEqual(Range(), Range())
def setUp(self):
"""Set up a few standard ranges."""
self.one = Range(Span(0, 100))
self.two = Range([Span(3, 5), Span(8, 11)])
self.three = Range([Span(6, 7), Span(15, 17), Span(30, 35)])
self.overlapping = Range([Span(6, 10), Span(7, 3)])
self.single = Range(0)
self.singles = Range([3, 11])
self.twocopy = Range(self.two)
self.twothree = Range([self.two, self.three])
self.empty = Range([Span(6, 6), Span(8, 8)])
def setUp(self):
"""Define some standard Spans"""
self.empty = Range(Span(0, 0))
self.full = Range(Span(30, 35))
self.overlapping = Range(Span(32, 36))
self.inside = Range(Span(31, 32))
self.before = Range(Span(25, 30))
self.after = Range(Span(35, 40))
self.reverse = Range(Span(30, 35, Reverse=True))
self.spans_zero = Range(Span(-5, 5))
def test_init(self):
"""Range init from Spans, numbers, or Ranges should work OK."""
#single span
self.assertEqual(self.one, Span(0, 100))
#list of spans
self.assertEqual(self.two.Spans, [Span(3, 5), Span(8, 11)])
#another range
self.assertEqual(self.two, self.twocopy)
#list of ranges
self.assertEqual(
self.twothree.Spans,
[Span(3, 5),
Span(8, 11),
Span(6, 7),
Span(15, 17),
Span(30, 35)])
#list of numbers
self.assertEqual(self.singles.Spans, [Span(3, 4), Span(11, 12)])
#single number
self.assertEqual(self.single.Spans, [Span(0, 1)])
#nothing
self.assertEqual(Range().Spans, [])
