def test_cmp(self):
cases = (
([None, None], [None, None], 0),
([None, 1], [1, None], 0),
([None, 1], [1, 2], 0),
([None, 1], [2, 3], -1),
([1, None], [None, 1], 0),
([1, None], [None, 0], 1),
([1, None], [-1, 0], 1),
([0, 1], [1, None], 0),
([0, 2], [1, None], 0),
([-1, 0], [1, None], -1),
)
for a, b, expected in cases:
dd('case:', a, b, expected)
a = rangeset.Range(*a)
b = rangeset.Range(*b)
rst = a.cmp(b)
dd('rst:', rst)
self.assertEqual(expected, rst)
def test_is_adjacent(self):
cases = (
([None, None], [None, None], False),
([None, 0], [0, None], True),
([None, 1], [1, None], True),
([None, 1], [2, None], False),
([None, 1], [None, 2], False),
([1, None], [1, None], False),
([0, 1], [1, 3], True),
([1, 1], [1, 1], True),
([0, 1], [2, 3], False),
(['', 'a'], ['a', 'b'], True),
(['', 'a'], ['aa', 'b'], False),
(['', 'c'], ['a', 'b'], False),
(['', None], ['a', 'b'], False),
(['', 'c'], [None, 'b'], False),
)
for a, b, expected in cases:
dd('case:', a, b, expected)
a = rangeset.Range(*a)
b = rangeset.Range(*b)
rst = a.is_adjacent(b)
dd('rst:', rst)
self.assertEqual(expected, rst)
def test_blockdesc(self):
block_id = 'd1g0006300000001230101idc000c62d8736c72800020000000001'
cases = ((None, {
'block_id': None,
'size': 0,
'range': None,
'ts_range': None,
'ref_num': 0,
'is_del': 0
}), ({
'block_id': block_id,
'range': ['a', 'b'],
'ts_range': ["124", None],
'ref_num': 0,
'size': 34,
'mtime': 1,
'is_del': 0
}, {
'block_id': BlockID(block_id),
'range': rangeset.Range('a', 'b'),
'ts_range': ["124", None],
'ref_num': 0,
'size': 34,
'mtime': 1,
'is_del': 0
}), ({
'block_id': BlockID(block_id),
'range': rangeset.Range('b', 'bb'),
'ts_range': ["1235", "456"],
'ref_num': 0,
'mtime': 1
}, {
'block_id': BlockID(block_id),
'range': rangeset.Range('b', 'bb'),
'ts_range': ["1235", "456"],
'ref_num': 0,
'size': 0,
'mtime': 1,
'is_del': 0,
}))
for b, expected in cases:
if b is None:
blk = BlockDesc()
expected['mtime'] = blk["mtime"]
else:
blk = BlockDesc(b)
self.assertEqual(expected, blk)
self.assertRaises(ValueError, BlockDesc, is_del='a')
self.assertRaises(ValueError, BlockDesc, size='a')
self.assertRaises(KeyError, BlockDesc, a=3)
def test_invalid_element_type(self):
cases = (
int, long, float, str, tuple, list
)
dd()
for typ in cases:
dd('test valid type: ', typ)
rangeset.Range(typ(), typ())
rangeset.RangeSet([[typ(), typ()]])
cases = (
lambda x: 1,
True,
)
dd()
for val in cases:
dd('test invalid type: ', typ)
self.assertRaises(TypeError, rangeset.Range, [val, val])
self.assertRaises(TypeError, rangeset.RangeSet, [[val, val]])
# incompatible type
self.assertRaises(TypeError, rangeset.Range, 1, 'a')
def test_length(self):
inf = float('inf')
cases = (
([None, None], inf),
([1, None], inf),
([None, 1], inf),
([None, ''], inf),
([None, ()], inf),
([None, []], inf),
([1, 1], 0),
([1, 2], 1),
([1.0, 2.2], 1.2),
(['', '\0'], 1.0/257),
(['', '\xff'], 256/257.0),
(['\0', '\0'], 0),
(['\0', '\1'], 1.0/257.0),
(['\0', '\xff'], 255.0/257.0),
(['ab', 'ab'], 0),
(['ab'*1024, 'ab'*1024], 0),
(['ab', 'abc'], (0x63 + 1) / (257.0**3)),
(['abb', 'abc'], 1 / 257.0 ** 3),
(['', '\xff' * 20], 1), # just like that 0.99999... == 1
)
for rng, expected in cases:
dd('case:', rng, expected)
rst = rangeset.Range(*rng).length()
dd('rst:', rst)
self.assertAlmostEqual(expected, rst)
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_substract(self):
cases = (
([None, None], [None, None], [None, None]),
([None, None], [1, None], [[None, 1], None]),
([None, None], [None, 1], [None, [1, None]]),
([None, None], [1, 3], [[None, 1], [3, None]]),
([None, 5], [5, 8], [[None, 5], None]),
([None, 5], [4, 8], [[None, 4], None]),
([None, 5], [1, 2], [[None, 1], [2, 5]]),
([None, 5], [None, 2], [None, [2, 5]]),
([None, 5], [None, 5], [None, None]),
([5, None], [1, 2], [None, [5, None]]),
([5, None], [1, 8], [None, [8, None]]),
([5, None], [5, 8], [None, [8, None]]),
([5, None], [6, 8], [[5, 6], [8, None]]),
([5, None], [6, None], [[5, 6], None]),
([5, None], [5, None], [None, None]),
([5, None], [4, None], [None, None]),
([5, 10], [5, None], [None, None]),
([5, 10], [6, None], [[5, 6], None]),
([5, 10], [6, 7], [[5, 6], [7, 10]]),
([5, 10], [6, 10], [[5, 6], None]),
)
for a, b, expected in cases:
dd('case:', a, b, expected)
a = rangeset.Range(*a)
b = rangeset.Range(*b)
# test module method
rst = rangeset.substract_range(a, b)
dd('rst:', rst)
self.assertEqual(expected, rst)
# test class method
rst = a.substract(b)
dd('rst:', rst)
self.assertEqual(expected, rst)
def test_intersect(self):
cases = (
([None, None], [None, None], [None, None] ),
([None, None], [1, None], [1, None] ),
([None, None], [None, 1], [None, 1] ),
([None, None], [1, 3], [1, 3] ),
([None, 5], [5, 8], None ),
([None, 5], [4, 8], [4, 5] ),
([None, 5], [1, 2], [1, 2] ),
([None, 5], [None, 2], [None, 2] ),
([None, 5], [None, 5], [None, 5] ),
([5, None], [1, 2], None ),
([5, None], [1, 8], [5, 8] ),
([5, None], [5, 8], [5, 8] ),
([5, None], [6, 8], [6, 8] ),
([5, None], [6, None], [6, None] ),
([5, None], [5, None], [5, None] ),
([5, None], [4, None], [5, None] ),
([5, 10], [5, None], [5, 10] ),
([5, 10], [6, None], [6, 10] ),
([5, 10], [6, 7], [6, 7] ),
([5, 10], [6, 10], [6, 10] ),
)
for a, b, expected in cases:
dd('case:', a, b, expected)
a = rangeset.Range(*a)
self.assertEqual(expected, a.intersect(rangeset.Range(*b)))
self.assertEqual(expected, a.intersect(rangeset.ValueRange(*(b+['bar']))))
a = rangeset.ValueRange(*(a+['ahh']))
if expected is not None:
expected = expected + ['ahh']
self.assertEqual(expected, a.intersect(rangeset.Range(*b)))
self.assertEqual(expected, a.intersect(rangeset.ValueRange(*(b+['bar']))))
def test_blockdesc(self):
block_id = 'd1g0006300000001230101c62d8736c72800020000000001'
cases = ((None,
{'block_id': None,
'size': 0,
'range': None,
'is_del': 0}),
({'block_id': block_id,
'range': ['a', 'b'],
'size': 34,
'is_del': 0},
{'block_id': BlockID(block_id),
'range': rangeset.Range('a', 'b'),
'size': 34,
'is_del': 0}),
({'block_id': BlockID(block_id),
'range': rangeset.Range('b', 'bb')},
{'block_id': BlockID(block_id),
'range': rangeset.Range('b', 'bb'),
'size': 0,
'is_del': 0, })
)
for b, expected in cases:
if b is None:
blk = BlockDesc()
else:
blk = BlockDesc(b)
self.assertEqual(expected, blk)
self.assertRaises(ValueError, BlockDesc, is_del='a')
self.assertRaises(ValueError, BlockDesc, size='a')
self.assertRaises(KeyError, BlockDesc, a=3)
def test_has(self):
cases = (
([None, None], 0, True),
([None, None], 1, True),
([None, 1], 0, True),
([None, 1], 1, False),
([None, 1], 2, False),
([1, None], 0, False),
([1, None], 1, True),
([1, None], 2, True),
([1, 1], 1, False),
([1, 3], 0, False),
([1, 3], 1, True),
([1, 3], 2, True),
([1, 3], 3, False),
([1, 3], 4, False),
([None, None], '', True),
(['', None], '', True),
([None, ''], '', False),
([None, 'a'], '', True),
(['', 'a'], '', True),
(['', 'a'], 'a', False),
(['', 'a'], 'b', False),
(['a', 'b'], 'a', True),
(['a', 'b'], 'b', False),
(['a', 'b'], 'c', False),
)
dd()
for rng, val, expected in cases:
dd('case:', rng, val, expected)
rng = rangeset.Range(*rng)
rst = rng.has(val)
self.assertEqual(expected, rst)
def _range(region_range=None):
if region_range is not None:
region_range = rangeset.Range(*region_range)
return region_range
from pykit import rangeset
if __name__ == '__main__':
r1 = rangeset.Range(1, 10)
r2 = rangeset.Range(10, 100)
r3 = rangeset.Range(-10, -5)
r4 = rangeset.Range(100, 200)
ir1 = rangeset.IntIncRange(1, 10)
print r1
print r2
print r3
print r4
print
print r1.cmp(r2)
print r1.cmp(r3)
print r1.cmp(r4)
print
print ir1.has(10)
print r1.has(10)
print r1.has(100)
print r1.has(-4)
print r1.has(5.3)
print r1.has('wo')
print r1.has([1, 2, 4, 5])
print
print r1.is_adjacent(r2)
print r2.is_adjacent(r1)
def _range(block_range=None):
if block_range is not None:
block_range = rangeset.Range(*block_range)
return block_range
def test_init(self):
a = rangeset.Range(1, 2)
dd(a)
a = rangeset.Range(1, 1)
dd(a)
