class SpanTests(TestCase):
"""Tests of the Span object."""
def setUp(self):
"""Define some standard Spans"""
self.empty = Span(0, 0)
self.full = Span(35, 30) #will convert to (30, 35) internally
self.overlapping = Span(32, 36)
self.inside = Span(31, 32)
self.before = Span(25, 30)
self.after = Span(35, 40)
self.reverse = Span(30, 35, Reverse=True)
self.spans_zero = Span(-5, 5)
def test_init(self):
"""Span object should init with Start, End, and Length"""
s = Span(0)
self.assertEqual(s.Start, 0)
self.assertEqual(s.End, 1)
self.assertEqual(s.Reverse, False)
#to get an empty interval, must specify start and end explicitly
t = Span(0, 0)
self.assertEqual(t.Start, 0)
self.assertEqual(t.End, 0)
self.assertEqual(t.Reverse, False)
#should be able to specify direction also
u = Span(5, 15, Reverse=True)
self.assertEqual(u.Start, 5)
self.assertEqual(u.End, 15)
self.assertEqual(u.Reverse, True)
#should be able to init from another span
v = Span(u)
self.assertEqual(v.Start, 5)
self.assertEqual(v.End, 15)
self.assertEqual(v.Reverse, True)
def test_contains(self):
"""Span object contains its start but not its end"""
self.assertNotContains(self.empty, 0)
self.assertContains(self.full, 30)
self.assertContains(self.full, 34)
self.assertNotContains(self.full, 35)
self.assertContains(self.full, self.inside)
self.assertNotContains(self.full, self.overlapping)
self.assertContains(self.spans_zero, 0)
self.assertContains(self.spans_zero, -5)
self.assertNotContains(self.spans_zero, 5)
def test_overlaps(self):
"""Span objects should be able to overlap points or spans"""
self.assertTrue(self.full.overlaps(self.overlapping))
self.assertFalse(self.full.overlaps(self.before))
self.assertFalse(self.before.overlaps(self.overlapping))
self.assertFalse(self.full.overlaps(self.after))
self.assertFalse(self.after.overlaps(self.before))
self.assertTrue(self.full.overlaps(self.inside))
self.assertTrue(self.spans_zero.overlaps(self.empty))
self.assertTrue(self.empty.overlaps(self.spans_zero))
def test_reverse(self):
"""Span reverse should change direction"""
self.assertFalse(self.empty.Reverse)
self.empty.reverse()
self.assertTrue(self.empty.Reverse)
self.empty.reverse()
self.assertFalse(self.empty.Reverse)
self.assertTrue(self.reverse.Reverse)
self.reverse.reverse()
self.assertFalse(self.reverse.Reverse)
def test_iter(self):
"""Span iter should loop through (integer) contents"""
self.assertEqual(list(iter(self.empty)), [])
self.assertEqual(list(iter(self.full)), [30, 31, 32, 33, 34])
self.assertEqual(list(iter(self.spans_zero)),
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4])
self.assertEqual(list(iter(self.inside)), [31])
self.assertEqual(list(self.reverse), [34, 33, 32, 31, 30])
def test_str(self):
"""Span str should print start, stop, reverse"""
self.assertEqual(str(self.empty), '(0,0,False)')
self.assertEqual(str(self.full), '(30,35,False)')
self.assertEqual(str(self.reverse), '(30,35,True)')
def test_len(self):
"""Span len should return difference between start and end"""
self.assertEqual(len(self.empty), 0)
self.assertEqual(len(self.full), 5)
self.assertEqual(len(self.inside), 1)
self.assertEqual(len(self.spans_zero), 10)
def test_cmp(self):
"""Span cmp should support sort by 1st/2nd index and direction"""
s, e, f, r, i, o = self.spans_zero, self.empty, self.full, \
self.reverse, self.inside, self.overlapping
n = Span(30, 36)
expected_order = [s, e, f, r, n, i, o]
first = expected_order[:]
first.sort()
second = [r, o, f, s, e, i, n]
second.sort()
for i, j in zip(first, second):
self.assertSameObj(i, j)
for i, j in zip(first, expected_order):
self.assertSameObj(i, j)
def test_startsBefore(self):
"""Span startsBefore should match hand-calculated results"""
e, f = self.empty, self.full
self.assertTrue(e.startsBefore(f))
self.assertFalse(f.startsBefore(e))
self.assertTrue(e.startsBefore(1))
self.assertTrue(e.startsBefore(1000))
self.assertFalse(e.startsBefore(0))
self.assertFalse(e.startsBefore(-1))
self.assertFalse(f.startsBefore(30))
self.assertTrue(f.startsBefore(31))
self.assertTrue(f.startsBefore(1000))
def test_startsAfter(self):
"""Span startsAfter should match hand-calculated results"""
e, f = self.empty, self.full
self.assertFalse(e.startsAfter(f))
self.assertTrue(f.startsAfter(e))
self.assertFalse(e.startsAfter(1))
self.assertFalse(e.startsAfter(1000))
self.assertFalse(e.startsAfter(0))
self.assertTrue(e.startsAfter(-1))
self.assertTrue(f.startsAfter(29))
self.assertFalse(f.startsAfter(30))
self.assertFalse(f.startsAfter(31))
self.assertFalse(f.startsAfter(1000))
def test_startsAt(self):
"""Span startsAt should return True if input matches"""
e, f = self.empty, self.full
s = Span(30, 1000)
self.assertTrue(e.startsAt(0))
self.assertTrue(f.startsAt(30))
self.assertTrue(s.startsAt(30))
self.assertTrue(f.startsAt(s))
self.assertTrue(s.startsAt(f))
self.assertFalse(e.startsAt(f))
self.assertFalse(e.startsAt(-1))
self.assertFalse(e.startsAt(1))
self.assertFalse(f.startsAt(29))
def test_startsInside(self):
"""Span startsInside should return True if input starts inside span"""
e, f, i, o = self.empty, self.full, self.inside, self.overlapping
self.assertFalse(e.startsInside(0))
self.assertFalse(f.startsInside(30))
self.assertFalse(e.startsInside(f))
self.assertTrue(i.startsInside(f))
self.assertFalse(f.startsInside(i))
self.assertTrue(o.startsInside(f))
self.assertFalse(o.endsInside(i))
def test_endsBefore(self):
"""Span endsBefore should match hand-calculated results"""
e, f = self.empty, self.full
self.assertTrue(e.endsBefore(f))
self.assertFalse(f.endsBefore(e))
self.assertTrue(e.endsBefore(1))
self.assertTrue(e.endsBefore(1000))
self.assertFalse(e.endsBefore(0))
self.assertFalse(e.endsBefore(-1))
self.assertFalse(f.endsBefore(30))
self.assertFalse(f.endsBefore(31))
self.assertTrue(f.endsBefore(1000))
def test_endsAfter(self):
"""Span endsAfter should match hand-calculated results"""
e, f = self.empty, self.full
self.assertFalse(e.endsAfter(f))
self.assertTrue(f.endsAfter(e))
self.assertFalse(e.endsAfter(1))
self.assertFalse(e.endsAfter(1000))
self.assertFalse(e.endsAfter(0))
self.assertTrue(e.endsAfter(-1))
self.assertTrue(f.endsAfter(29))
self.assertTrue(f.endsAfter(30))
self.assertTrue(f.endsAfter(34))
self.assertFalse(f.endsAfter(35))
self.assertFalse(f.endsAfter(1000))
def test_endsAt(self):
"""Span endsAt should return True if input matches"""
e, f = self.empty, self.full
s = Span(30, 1000)
t = Span(-100, 35)
self.assertTrue(e.endsAt(0))
self.assertTrue(f.endsAt(35))
self.assertTrue(s.endsAt(1000))
self.assertFalse(f.endsAt(s))
self.assertFalse(s.endsAt(f))
self.assertTrue(f.endsAt(t))
self.assertTrue(t.endsAt(f))
def test_endsInside(self):
"""Span endsInside should return True if input ends inside span"""
e, f, i, o = self.empty, self.full, self.inside, self.overlapping
self.assertFalse(e.endsInside(0))
self.assertFalse(f.endsInside(30))
self.assertFalse(f.endsInside(34))
self.assertFalse(f.endsInside(35))
self.assertFalse(e.endsInside(f))
self.assertTrue(i.endsInside(f))
self.assertFalse(f.endsInside(i))
self.assertFalse(o.endsInside(f))
self.assertFalse(o.endsInside(i))
self.assertTrue(e.endsInside(Span(-1, 1)))
self.assertTrue(e.endsInside(Span(0, 1)))
self.assertFalse(e.endsInside(Span(-1, 0)))
class SpanTests(TestCase):
"""Tests of the Span object."""
def setUp(self):
"""Define some standard Spans"""
self.empty = Span(0, 0)
self.full = Span(35, 30) #will convert to (30, 35) internally
self.overlapping = Span(32, 36)
self.inside = Span(31, 32)
self.before = Span(25, 30)
self.after = Span(35, 40)
self.reverse = Span(30, 35, Reverse=True)
self.spans_zero = Span(-5, 5)
def test_init(self):
"""Span object should init with Start, End, and Length"""
s = Span(0)
self.assertEqual(s.Start, 0)
self.assertEqual(s.End, 1)
self.assertEqual(s.Reverse, False)
#to get an empty interval, must specify start and end explicitly
t = Span(0, 0)
self.assertEqual(t.Start, 0)
self.assertEqual(t.End, 0)
self.assertEqual(t.Reverse, False)
#should be able to specify direction also
u = Span(5, 15, Reverse=True)
self.assertEqual(u.Start, 5)
self.assertEqual(u.End, 15)
self.assertEqual(u.Reverse, True)
#should be able to init from another span
v = Span(u)
self.assertEqual(v.Start, 5)
self.assertEqual(v.End, 15)
self.assertEqual(v.Reverse, True)
def test_contains(self):
"""Span object contains its start but not its end"""
self.assertNotContains(self.empty, 0)
self.assertContains(self.full, 30)
self.assertContains(self.full, 34)
self.assertNotContains(self.full, 35)
self.assertContains(self.full, self.inside)
self.assertNotContains(self.full, self.overlapping)
self.assertContains(self.spans_zero, 0)
self.assertContains(self.spans_zero, -5)
self.assertNotContains(self.spans_zero, 5)
def test_overlaps(self):
"""Span objects should be able to overlap points or spans"""
self.assertTrue(self.full.overlaps(self.overlapping))
self.assertFalse(self.full.overlaps(self.before))
self.assertFalse(self.before.overlaps(self.overlapping))
self.assertFalse(self.full.overlaps(self.after))
self.assertFalse(self.after.overlaps(self.before))
self.assertTrue(self.full.overlaps(self.inside))
self.assertTrue(self.spans_zero.overlaps(self.empty))
self.assertTrue(self.empty.overlaps(self.spans_zero))
def test_reverse(self):
"""Span reverse should change direction"""
self.assertFalse(self.empty.Reverse)
self.empty.reverse()
self.assertTrue(self.empty.Reverse)
self.empty.reverse()
self.assertFalse(self.empty.Reverse)
self.assertTrue(self.reverse.Reverse)
self.reverse.reverse()
self.assertFalse(self.reverse.Reverse)
def test_iter(self):
"""Span iter should loop through (integer) contents"""
self.assertEqual(list(iter(self.empty)), [])
self.assertEqual(list(iter(self.full)), [30,31,32,33,34])
self.assertEqual(list(iter(self.spans_zero)),[-5,-4,-3,-2,-1,0,1,2,3,4])
self.assertEqual(list(iter(self.inside)), [31])
self.assertEqual(list(self.reverse), [34,33,32,31,30])
def test_str(self):
"""Span str should print start, stop, reverse"""
self.assertEqual(str(self.empty), '(0,0,False)')
self.assertEqual(str(self.full), '(30,35,False)')
self.assertEqual(str(self.reverse), '(30,35,True)')
def test_len(self):
"""Span len should return difference between start and end"""
self.assertEqual(len(self.empty), 0)
self.assertEqual(len(self.full), 5)
self.assertEqual(len(self.inside),1)
self.assertEqual(len(self.spans_zero), 10)
def test_cmp(self):
"""Span cmp should support sort by 1st/2nd index and direction"""
s, e, f, r, i, o = self.spans_zero, self.empty, self.full, \
self.reverse, self.inside, self.overlapping
n = Span(30, 36)
expected_order = [s, e, f, r, n, i, o]
first = expected_order[:]
first.sort()
second = [r, o, f, s, e, i, n]
second.sort()
for i, j in zip(first, second):
self.assertSameObj(i, j)
for i, j in zip(first, expected_order):
self.assertSameObj(i, j)
def test_startsBefore(self):
"""Span startsBefore should match hand-calculated results"""
e, f = self.empty, self.full
self.assertTrue(e.startsBefore(f))
self.assertFalse(f.startsBefore(e))
self.assertTrue(e.startsBefore(1))
self.assertTrue(e.startsBefore(1000))
self.assertFalse(e.startsBefore(0))
self.assertFalse(e.startsBefore(-1))
self.assertFalse(f.startsBefore(30))
self.assertTrue(f.startsBefore(31))
self.assertTrue(f.startsBefore(1000))
def test_startsAfter(self):
"""Span startsAfter should match hand-calculated results"""
e, f = self.empty, self.full
self.assertFalse(e.startsAfter(f))
self.assertTrue(f.startsAfter(e))
self.assertFalse(e.startsAfter(1))
self.assertFalse(e.startsAfter(1000))
self.assertFalse(e.startsAfter(0))
self.assertTrue(e.startsAfter(-1))
self.assertTrue(f.startsAfter(29))
self.assertFalse(f.startsAfter(30))
self.assertFalse(f.startsAfter(31))
self.assertFalse(f.startsAfter(1000))
def test_startsAt(self):
"""Span startsAt should return True if input matches"""
e, f = self.empty, self.full
s = Span(30, 1000)
self.assertTrue(e.startsAt(0))
self.assertTrue(f.startsAt(30))
self.assertTrue(s.startsAt(30))
self.assertTrue(f.startsAt(s))
self.assertTrue(s.startsAt(f))
self.assertFalse(e.startsAt(f))
self.assertFalse(e.startsAt(-1))
self.assertFalse(e.startsAt(1))
self.assertFalse(f.startsAt(29))
def test_startsInside(self):
"""Span startsInside should return True if input starts inside span"""
e, f, i, o = self.empty, self.full, self.inside, self.overlapping
self.assertFalse(e.startsInside(0))
self.assertFalse(f.startsInside(30))
self.assertFalse(e.startsInside(f))
self.assertTrue(i.startsInside(f))
self.assertFalse(f.startsInside(i))
self.assertTrue(o.startsInside(f))
self.assertFalse(o.endsInside(i))
def test_endsBefore(self):
"""Span endsBefore should match hand-calculated results"""
e, f = self.empty, self.full
self.assertTrue(e.endsBefore(f))
self.assertFalse(f.endsBefore(e))
self.assertTrue(e.endsBefore(1))
self.assertTrue(e.endsBefore(1000))
self.assertFalse(e.endsBefore(0))
self.assertFalse(e.endsBefore(-1))
self.assertFalse(f.endsBefore(30))
self.assertFalse(f.endsBefore(31))
self.assertTrue(f.endsBefore(1000))
def test_endsAfter(self):
"""Span endsAfter should match hand-calculated results"""
e, f = self.empty, self.full
self.assertFalse(e.endsAfter(f))
self.assertTrue(f.endsAfter(e))
self.assertFalse(e.endsAfter(1))
self.assertFalse(e.endsAfter(1000))
self.assertFalse(e.endsAfter(0))
self.assertTrue(e.endsAfter(-1))
self.assertTrue(f.endsAfter(29))
self.assertTrue(f.endsAfter(30))
self.assertTrue(f.endsAfter(34))
self.assertFalse(f.endsAfter(35))
self.assertFalse(f.endsAfter(1000))
def test_endsAt(self):
"""Span endsAt should return True if input matches"""
e, f = self.empty, self.full
s = Span(30, 1000)
t = Span(-100, 35)
self.assertTrue(e.endsAt(0))
self.assertTrue(f.endsAt(35))
self.assertTrue(s.endsAt(1000))
self.assertFalse(f.endsAt(s))
self.assertFalse(s.endsAt(f))
self.assertTrue(f.endsAt(t))
self.assertTrue(t.endsAt(f))
def test_endsInside(self):
"""Span endsInside should return True if input ends inside span"""
e, f, i, o = self.empty, self.full, self.inside, self.overlapping
self.assertFalse(e.endsInside(0))
self.assertFalse(f.endsInside(30))
self.assertFalse(f.endsInside(34))
self.assertFalse(f.endsInside(35))
self.assertFalse(e.endsInside(f))
self.assertTrue(i.endsInside(f))
self.assertFalse(f.endsInside(i))
self.assertFalse(o.endsInside(f))
self.assertFalse(o.endsInside(i))
self.assertTrue(e.endsInside(Span(-1,1)))
self.assertTrue(e.endsInside(Span(0,1)))
self.assertFalse(e.endsInside(Span(-1,0)))
