def test_get_min(self):
cases = (
(((1, 2, '12'), ), (0, [1, 2, '12'], '12')),
(((1, 2, '34'), (3, 4, '12')), (1, [3, 4, '12'], '12')),
(((1, 2, '34'), (3, 4, '12'), (5, 6, '56')), (1, [3, 4, '12'], '12')),
(((1, 2, '12'), (3, 4, '34'), (5, 6, '12')), (0, [1, 2, '12'], '12')),
)
for src_rngs, expected in cases:
dd("expected index: ", expected[0])
dd("expected range: ", rangeset.ValueRange(*expected[1]))
dd("expected value: ", expected[2])
rd = rangeset.RangeDict(src_rngs)
idx, rng, val = rd.get_min()
dd("got index: ", idx)
dd("got range: ", rng)
dd("got value: ", val)
self.assertEqual(idx, expected[0])
self.assertEqual(rng, rangeset.ValueRange(*expected[1]))
self.assertEqual(val, expected[2])
rd = rangeset.RangeDict()
self.assertRaises(ValueError, rd.get_min)
def test_intersect(self):
# intersect is implemented with substract, thus we simplified the test.
a = rangeset.RangeDict([[1, 3, 'a'], [5, 10, 'b']])
b = rangeset.RangeDict([[2, 8, 'x']])
self.assertEqual([[2, 3, 'a'], [5, 8, 'b']], rangeset.intersect(a, b))
def test_substract(self):
cases = (
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[None, None]], []),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[None, 1]], [[1, 10, 'a'], [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[None, 10]], [ [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[None, 11]], [ [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[9, 11]], [[None, 9, 'a'], [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[10, 11]], [[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[11, 12]], [[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[19, 20]], [[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[19, 21]], [[None, 10, 'a'], [21, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[20, 21]], [[None, 10, 'a'], [21, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[24, 25]], [[None, 10, 'a'], [20, 24, 'b'], [25, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[29, 30]], [[None, 10, 'a'], [20, 29, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[29, 31]], [[None, 10, 'a'], [20, 29, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[30, 31]], [[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[31, 32]], [[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[39, 40]], [[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[39, 41]], [[None, 10, 'a'], [20, 30, 'b'], [41, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[40, 41]], [[None, 10, 'a'], [20, 30, 'b'], [41, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[41, 42]], [[None, 10, 'a'], [20, 30, 'b'], [40, 41, 'c'], [42, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[41, None]], [[None, 10, 'a'], [20, 30, 'b'], [40, 41, 'c'], ]),
([[20, 30, 'a'] ], [[20, 24], [25, 30]], [[24, 25, 'a']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[20, 24], [25, 30]], [[None, 10, 'a'], [24, 25, 'b'], [40, None, 'c'], ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [[1, 2], [8, 25], [35, 45]], [[None, 1, 'a'], [2, 8, 'a'], [25, 30, 'b'], [45, None, 'c']]),
)
dd()
for a, b, expected in cases:
dd('case:', a, b, expected)
# RangeDict - RangeSet
a = rangeset.RangeDict(a)
b = rangeset.RangeSet(b)
rst = rangeset.substract(a, b)
dd('rst:', rst)
self.assertEqual(expected, rst)
# RangeDict - RangeDict
b = rangeset.RangeDict(b)
rst = rangeset.substract(a, b)
dd('rst:', rst)
self.assertEqual(expected, rst)
def test_substract(self):
r = rangeset.RangeDict(self.inp, dimension=2)
r = rangeset.substract(r, rangeset.RangeDict([[0.5, 1.5, None]]))
dd(r)
self.assertRaises(KeyError, r.get, 2)
self.assertRaises(KeyError, r.get, 2, 'e')
self.assertEqual('bd', r.get(0, 'b'))
self.assertEqual('ac', r.get(1.6, 'b'))
r = rangeset.substract(r, rangeset.RangeDict([[0, 1.5, None]]))
dd(r)
self.assertRaises(KeyError, r.get, 0)
def test_normalize(self):
cases = (
([(None, 2, '12'), [2, 3, '12']],
[[None, 3, '12']]),
([(None, 2, '12'), [2, None, '12']],
[[None, None, '12']]),
([(1, 2, '12'), [2, 3, '12']],
[[1, 3, '12']]),
([(1, 2, '12'), [2, 3, '12'], [3, 4, '12']],
[[1, 4, '12']]),
([(1, 2, '12'), [2, 3, 'foo']],
[[1, 2, '12'], [2, 3, 'foo']]),
)
for ori, expected in cases:
rd = rangeset.RangeDict(ori)
rd.normalize()
self.assertEqual(expected, rd)
def test_get(self):
r = rangeset.RangeDict(self.inp, dimension=2)
cases = (
(0.5, 'a', 'ab'),
(0.5, 'c', 'bd'),
(1.5, 'a', 'ac'),
(1.5, 'c', 'cd'),
)
for tm, string, expected in cases:
dd(tm, string, expected)
rst = r.get(tm).get(string)
dd('rst:', rst)
self.assertEqual(expected, rst)
# in one get
rst = r.get(tm, string)
dd('rst:', rst)
self.assertEqual(expected, rst)
# too many args
self.assertRaises(TypeError, r.get, 1, 'a', 1)
def test_add(self):
r = rangeset.RangeDict(self.inp, dimension=2)
r.add([2, None], [['a', 'd', 'ad']])
rst = r.get(2.5, 'b')
self.assertEqual('ad', rst)
self.assertRaises(KeyError, r.get, 2.5, 'e')
def _levels(levels=None):
if levels is None:
levels = []
for level, blocks in enumerate(levels):
for b in blocks:
b[2] = BlockDesc(b[2])
levels[level] = rangeset.RangeDict(blocks)
return levels
def _levels(levels=None):
if levels is None:
levels = []
for level, range_bids in enumerate(levels):
for b in range_bids:
b[2] = BlockID(b[2])
levels[level] = rangeset.RangeDict(range_bids)
return levels
def add_block(self, active_range, block, level=None):
max_level = len(self['levels']) - 1
if level is None:
level = max_level + 1
elif level < 0 or level > max_level + 1:
raise LevelOutOfBound('level is invalid. except level >= 0 and level <= {0}, '
'got: {1}'.format(max_level + 1, level))
if level == max_level + 1:
self['levels'].append(rangeset.RangeDict())
desc = BlockDesc(block)
self['levels'][level].add(active_range, desc)
def test_find_overlapped(self):
cases = (
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [None, None], [[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [None, 1], [[None, 10, 'a'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [None, 10], [[None, 10, 'a'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [None, 11], [[None, 10, 'a'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [9, 11], [[None, 10, 'a'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [9, 21], [[None, 10, 'a'], [20, 30, 'b'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [9, 40], [[None, 10, 'a'], [20, 30, 'b'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [9, 41], [[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [10, 11], [ ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [11, 12], [ ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [19, 20], [ ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [19, 21], [ [20, 30, 'b'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [20, 21], [ [20, 30, 'b'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [24, 25], [ [20, 30, 'b'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [29, 30], [ [20, 30, 'b'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [29, 31], [ [20, 30, 'b'] ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [29, 41], [ [20, 30, 'b'], [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [30, 31], [ ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [31, 32], [ ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [39, 40], [ ]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [39, 41], [ [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [40, 41], [ [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [41, 42], [ [40, None, 'c']]),
([[None, 10, 'a'], [20, 30, 'b'], [40, None, 'c']], [41, None], [ [40, None, 'c']]),
)
dd()
for a, b, expected in cases:
dd('case:', a, b, expected)
a = rangeset.RangeDict(a)
self.assertEqual(expected, a.find_overlapped(b))
self.assertEqual(expected, a.find_overlapped(rangeset.Range(*b)))
self.assertEqual(expected, a.find_overlapped(rangeset.ValueRange(*(b+['bar']))))
a = rangeset.RangeSet([x[:2] for x in a])
expected = [x[:2] for x in expected]
self.assertEqual(expected, a.find_overlapped(b))
self.assertEqual(expected, a.find_overlapped(rangeset.Range(*b)))
self.assertEqual(expected, a.find_overlapped(rangeset.ValueRange(*(b+['bar']))))
def test_init(self):
rd = rangeset.RangeDict([(1, 2, '12'), [3, 4, '34']])
cases = (
1, 1.5, 3, 3.5,
)
for present in cases:
self.assertTrue(rd.has(present))
cases = (
0, 2, 2.5, 4, 4.5
)
for absent in cases:
self.assertFalse(rd.has(absent))
def test_add(self):
cases = (
([None, 0, 'xx'], [[None, 0, 'xx'], [1, 5, '15'], [7, 9, '79']]),
([None, 1, 'xx'], [[None, 1, 'xx'], [1, 5, '15'], [7, 9, '79']]),
([None, 2, 'xx'], [[None, 2, 'xx'], [2, 5, '15'], [7, 9, '79']]),
([0, 2, 'xx'], [[0, 2, 'xx'], [2, 5, '15'], [7, 9, '79']]),
([1, 2, 'xx'], [[1, 2, 'xx'], [2, 5, '15'], [7, 9, '79']]),
([1, 5, 'xx'], [[1, 5, 'xx'], [7, 9, '79']]),
([2, 3, 'xx'], [[1, 2, '15'], [2, 3, 'xx'], [3, 5, '15'], [7, 9, '79']]),
([2, 4, 'xx'], [[1, 2, '15'], [2, 4, 'xx'], [4, 5, '15'], [7, 9, '79']]),
([2, 5, 'xx'], [[1, 2, '15'], [2, 5, 'xx'], [7, 9, '79']]),
([2, 6, 'xx'], [[1, 2, '15'], [2, 6, 'xx'], [7, 9, '79']]),
([2, 7, 'xx'], [[1, 2, '15'], [2, 7, 'xx'], [7, 9, '79']]),
([2, 8, 'xx'], [[1, 2, '15'], [2, 8, 'xx'], [8, 9, '79']]),
([5, 7, 'xx'], [[1, 5, '15'], [5, 7, 'xx'], [7, 9, '79']]),
([5, 8, 'xx'], [[1, 5, '15'], [5, 8, 'xx'], [8, 9, '79']]),
([6, 8, 'xx'], [[1, 5, '15'], [6, 8, 'xx'], [8, 9, '79']]),
([6, 9, 'xx'], [[1, 5, '15'], [6, 9, 'xx'], ]),
([6, 10, 'xx'], [[1, 5, '15'], [6, 10, 'xx'], ]),
([7, 8, 'xx'], [[1, 5, '15'], [7, 8, 'xx'], [8, 9, '79']]),
([7, 9, 'xx'], [[1, 5, '15'], [7, 9, 'xx']]),
([7, 10, 'xx'], [[1, 5, '15'], [7, 10, 'xx']]),
([8, 10, 'xx'], [[1, 5, '15'], [7, 8, '79'], [8, 10, 'xx']]),
([9, 10, 'xx'], [[1, 5, '15'], [7, 9, '79'], [9, 10, 'xx']]),
([10, 11, 'xx'], [[1, 5, '15'], [7, 9, '79'], [10, 11, 'xx']]),
([10, None, 'xx'], [[1, 5, '15'], [7, 9, '79'], [10, None, 'xx']]),
([None, None, 'xx'], [[None, None, 'xx']]),
([2, None, 'xx'], [[1, 2, '15'], [2, None, 'xx']]),
([0, 3, '15'], [[0, 5, '15'], [7, 9, '79']]),
([2, 6, '15'], [[1, 6, '15'], [7, 9, '79']]),
([2, 8, '15'], [[1, 8, '15'], [8, 9, '79']]),
)
for a, expected in cases:
rd = rangeset.RangeDict([(1, 5, '15'), [7, 9, '79']])
dd('init:', rd)
dd('add:', a)
dd('expected:', expected)
rd.add(a[:2], a[2])
self.assertEqual(expected, rd)
def add_block(self, active_range, block_id, level=None, allow_exist=False):
if self.has(block_id):
if not allow_exist:
raise BlockAreadyInRegion('block_id {bid}'.format(bid=block_id))
return
max_level = len(self['levels']) - 1
if level is None:
level = max_level + 1
elif level < 0 or level > max_level + 1:
raise LevelOutOfBound('level is invalid. except level >= 0 and level <= {0}, '
'got: {1}'.format(max_level + 1, level))
if level == max_level + 1:
self['levels'].append(rangeset.RangeDict())
self['levels'][level].add(active_range, BlockID(block_id))
def test_get(self):
rd = rangeset.RangeDict([(1, 2, '12'), [3, 4, '34']])
cases = (
(1, '12'),
(1.5, '12'),
(3, '34'),
(3.5, '34'),
)
for present, val in cases:
self.assertEqual(val, rd.get(present))
cases = (
0, 2, 2.5, 4, 4.5
)
for absent in cases:
self.assertRaises(KeyError, rd.get, absent)
def test_get_min_is_lt(self):
cases = (
(((1, 2, '12'), (3, 4, '34'), (5, 6, '12')), lambda a, b: a < b, (0, [1, 2, '12'], '12')),
(((1, 2, '12'), (3, 4, '34'), (5, 6, '12')), lambda a, b: a > b, (1, [3, 4, '34'], '34')),
)
for src_rngs, is_lt, expected in cases:
dd("expected index: ", expected[0])
dd("expected range: ", rangeset.ValueRange(*expected[1]))
dd("expected value: ", expected[2])
rd = rangeset.RangeDict(src_rngs)
idx, rng, val = rd.get_min(is_lt)
dd("got index: ", idx)
dd("got range: ", rng)
dd("got value: ", val)
self.assertEqual(idx, expected[0])
self.assertEqual(rng, rangeset.ValueRange(*expected[1]))
self.assertEqual(val, expected[2])
def test_adjacent_elts(self):
rd = rangeset.RangeDict([(1, 2, '12'), [2, 3, '23']])
self.assertEqual('12', rd.get(1.5))
self.assertEqual('23', rd.get(2))