def testSubsetKnown(self):
"Test Ranges.subset() against some known values."
for l1, l2, res in self.knownSubsetValues:
r1 = ranges.Ranges()
r1.addlist(l1)
r2 = ranges.Ranges()
r2.addlist(l2)
self.assertEqual(r1.subset(r2), res)
def testStrResults(self):
"Test the result of str() of a Ranges on known values."
self.assertEqual(str(ranges.Ranges()), "<Ranges: >")
self.assertEqual(str(ranges.Ranges(1, 10)), "<Ranges: 1-10>")
self.assertEqual(str(ranges.Ranges(1, 1)), "<Ranges: 1>")
r = ranges.Ranges()
r.addrange(5, 10)
r.addnum(1)
self.assertEqual(str(r), "<Ranges: 1 5-10>")
def testAddSubRanges(self):
"Test that addRanges and delRanges work right."
for al, bl, ares, sres in self.knownAddSubs:
r1 = ranges.Ranges(al[0], al[1])
r2 = ranges.Ranges(bl[0], bl[1])
r1.addRanges(r2)
self.assertEqual(str(r1), ares)
r1.delRanges(r2)
self.assertEqual(str(r1), sres)
def testAdjacentFunc(self):
"Test Ranges.adjacent() with known values."
e = ranges.Ranges()
for al, bl, res in self.knownAdjacents:
r1 = ranges.Ranges(al[0], al[1])
r2 = ranges.Ranges(bl[0], bl[1])
self.assertEqual(r1.adjacent(r2), res)
# adjacency is reflexive
self.assertEqual(r2.adjacent(r1), res)
# An empty range should never be adjacent.
for r in (r1, r2):
self.assertEqual(e.adjacent(r), 0)
self.assertEqual(r.adjacent(e), 0)
def testAddSubFunc(self):
"Test that object addition and subtraction work."
e = ranges.Ranges()
for al, bl, ares, sres in self.knownAddSubs:
r1 = ranges.Ranges(al[0], al[1])
r2 = ranges.Ranges(bl[0], bl[1])
# Basic tests for operators.
for r in (r1, r2):
self.assertEqual(r == (r + r), 1)
self.assertEqual(e == (r - r), 1)
ra = r1 + r2
rs = r1 - r2
self.assertEqual(str(ra), ares)
self.assertEqual(str(rs), sres)
def testKnownInitfailures(self):
"Test that Ranges fail to initialize for certain known bad inputs."
self.assertRaises(TypeError, ranges.Ranges, 1, 2, 3, 4)
self.assertRaises(TypeError, ranges.Ranges, 1)
self.assertRaises(ranges.BadRange, ranges.Ranges, 10, 9)
r = ranges.Ranges()
self.assertRaises(ranges.BadRange, r.addrange, 10, 9)
self.assertRaises(ranges.BadRange, r.delrange, 10, 9)
def testIntersectBasics(self):
"Test for basic correctness of Ranges.intersect()."
e = ranges.Ranges()
# Empty ranges do not intersect each other.
# In fact, they intersect nothing.
self.assertEqual(e.intersect(e), 0)
for l1, l2, res in self.knownIntersectRanges:
r1 = ranges.Ranges()
r1.addlist(l1)
r2 = ranges.Ranges()
r2.addlist(l2)
# Empty set intersects neither.
self.assertEqual(e.intersect(r1), 0)
self.assertEqual(r2.intersect(e), 0)
# Test core operation.
self.assertEqual(r1.intersect(r2), res,
"failed on %s versus %s" % (str(r1), str(r2)))
self.assertEqual(r2.intersect(r1), res)
def testLenOperation(self):
"Test len(Ranges) for basic proper operation."
r = ranges.Ranges()
self.assertEqual(len(r), 0)
r.addnum(1)
self.assertEqual(len(r), 1)
r.addnum(2)
self.assertEqual(len(r), 2)
r.addrange(10, 15)
self.assertEqual(len(r), 8)
def testInOperator(self):
"""Test the 'in' operator of Ranges."""
r = ranges.Ranges(2, 10)
self.assertEqual(0 in r, 0)
self.assertEqual(2 in r, 1)
# Now, assert that every element in every one of our
# test lists above is in itself.
for elist, ign in self.knownAddValues:
r = ranges.Ranges()
r.addlist(elist)
for e in r:
self.assertEqual(e in r, 1)
# Another test; this is designed to test the binary
# search stuff.
rl = ((2, 10), (15, 17), (20, 25), (30, 35), (40, 45), (50, 60),
(70, 75), (80, 85), (90, 95), (100, 105), (110, 120), (125, 128),
(130, 135), (140, 150))
r = ranges.Ranges()
r.addlist(rl)
for i in (2, 10, 16, 20, 144, 91, 85):
self.assertEqual(i in r, 1)
for i in (1, 11, 151, 200, 0, 88):
self.assertEqual(i in r, 0)
def testSubsetOperator(self):
"Test Ranges.subset() for basic proper operation."
e = ranges.Ranges()
# we don't use negative range values so far.
mr = ranges.Ranges(-10, -5)
# An empty range should be the subset of itself.
self.assertEqual(e.subset(e), 1)
# Test basic reflexitivity on our magic values.
for il, res in self.knownAddValues:
r = ranges.Ranges()
r.addlist(il)
# ... because empty ranges are a subset of
# everything?
self.assertEqual(r.subset(e), 1)
# r should be a subset of itself?
self.assertEqual(r.subset(r), 1)
# mr should not be a subset.
self.assertEqual(r.subset(mr), 0)
# Add an out-of-range value and see if it is
# rejected.
r1 = r.copy()
r1.addnum(1000)
self.assertEqual(r.subset(r1), 0)
self.assertEqual(r1.subset(r), 1)
def testAddSubValues(self):
"Test that adding up a series of ranges results in a known list and that subtracting them again yields an empty list."
for elist, rval in self.knownAddValues:
r = ranges.Ranges()
r.addlist(elist)
self.assertEqual(r._l, rval)
r.dellist(elist)
self.assertEqual(r._l, [])
# Now we check the stability of these results under
# inverting the order of both removals and then
# additions.
r.addlist(elist)
# Turn the elist tuple into a list so we can
# reverse it.
elist = list(elist)
elist.reverse()
# Delete it.
r.dellist(elist)
self.assertEqual(r._l, [])
# Add it back in to the null and assert that it is
# the same.
r.addlist(elist)
self.assertEqual(r._l, rval)
def testIterOperation(self):
"Test that Ranges iteration yields known values."
for initlist, restup in self.knownIterValues:
r = ranges.Ranges()
r.addlist(initlist)
self.assertEqual(tuple(r), restup)
