import sys import unittest from test.support import import_helper from collections import UserList py_bisect = import_helper.import_fresh_module('bisect', blocked=['_bisect']) c_bisect = import_helper.import_fresh_module('bisect', fresh=['_bisect']) class Range(object): """A trivial range()-like object that has an insert() method.""" def __init__(self, start, stop): self.start = start self.stop = stop self.last_insert = None def __len__(self): return self.stop - self.start def __getitem__(self, idx): n = self.stop - self.start if idx < 0: idx += n if idx >= n: raise IndexError(idx) return self.start + idx def insert(self, idx, item): self.last_insert = idx, item class TestBisect: def setUp(self): self.precomputedCases = [ (self.module.bisect_right, [], 1, 0), (self.module.bisect_right, [1], 0, 0), (self.module.bisect_right, [1], 1, 1), (self.module.bisect_right, [1], 2, 1), (self.module.bisect_right, [1, 1], 0, 0), (self.module.bisect_right, [1, 1], 1, 2), (self.module.bisect_right, [1, 1], 2, 2), (self.module.bisect_right, [1, 1, 1], 0, 0), (self.module.bisect_right, [1, 1, 1], 1, 3), (self.module.bisect_right, [1, 1, 1], 2, 3), (self.module.bisect_right, [1, 1, 1, 1], 0, 0), (self.module.bisect_right, [1, 1, 1, 1], 1, 4), (self.module.bisect_right, [1, 1, 1, 1], 2, 4), (self.module.bisect_right, [1, 2], 0, 0), (self.module.bisect_right, [1, 2], 1, 1), (self.module.bisect_right, [1, 2], 1.5, 1), (self.module.bisect_right, [1, 2], 2, 2), (self.module.bisect_right, [1, 2], 3, 2), (self.module.bisect_right, [1, 1, 2, 2], 0, 0), (self.module.bisect_right, [1, 1, 2, 2], 1, 2), (self.module.bisect_right, [1, 1, 2, 2], 1.5, 2), (self.module.bisect_right, [1, 1, 2, 2], 2, 4), (self.module.bisect_right, [1, 1, 2, 2], 3, 4), (self.module.bisect_right, [1, 2, 3], 0, 0), (self.module.bisect_right, [1, 2, 3], 1, 1), (self.module.bisect_right, [1, 2, 3], 1.5, 1), (self.module.bisect_right, [1, 2, 3], 2, 2), (self.module.bisect_right, [1, 2, 3], 2.5, 2), (self.module.bisect_right, [1, 2, 3], 3, 3), (self.module.bisect_right, [1, 2, 3], 4, 3), (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0), (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 1), (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1), (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 3), (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3), (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 6), (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6), (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 10), (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10), (self.module.bisect_left, [], 1, 0), (self.module.bisect_left, [1], 0, 0), (self.module.bisect_left, [1], 1, 0), (self.module.bisect_left, [1], 2, 1), (self.module.bisect_left, [1, 1], 0, 0), (self.module.bisect_left, [1, 1], 1, 0), (self.module.bisect_left, [1, 1], 2, 2), (self.module.bisect_left, [1, 1, 1], 0, 0), (self.module.bisect_left, [1, 1, 1], 1, 0), (self.module.bisect_left, [1, 1, 1], 2, 3), (self.module.bisect_left, [1, 1, 1, 1], 0, 0), (self.module.bisect_left, [1, 1, 1, 1], 1, 0), (self.module.bisect_left, [1, 1, 1, 1], 2, 4), (self.module.bisect_left, [1, 2], 0, 0), (self.module.bisect_left, [1, 2], 1, 0), (self.module.bisect_left, [1, 2], 1.5, 1), (self.module.bisect_left, [1, 2], 2, 1), (self.module.bisect_left, [1, 2], 3, 2), (self.module.bisect_left, [1, 1, 2, 2], 0, 0), (self.module.bisect_left, [1, 1, 2, 2], 1, 0), (self.module.bisect_left, [1, 1, 2, 2], 1.5, 2), (self.module.bisect_left, [1, 1, 2, 2], 2, 2), (self.module.bisect_left, [1, 1, 2, 2], 3, 4), (self.module.bisect_left, [1, 2, 3], 0, 0), (self.module.bisect_left, [1, 2, 3], 1, 0), (self.module.bisect_left, [1, 2, 3], 1.5, 1), (self.module.bisect_left, [1, 2, 3], 2, 1), (self.module.bisect_left, [1, 2, 3], 2.5, 2), (self.module.bisect_left, [1, 2, 3], 3, 2), (self.module.bisect_left, [1, 2, 3], 4, 3), (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0), (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 0), (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1), (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 1), (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3), (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 3), (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6), (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 6), (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10) ] def test_precomputed(self): for func, data, elem, expected in self.precomputedCases: self.assertEqual(func(data, elem), expected) self.assertEqual(func(UserList(data), elem), expected) def test_negative_lo(self): # Issue 3301 mod = self.module self.assertRaises(ValueError, mod.bisect_left, [1, 2, 3], 5, -1, 3) self.assertRaises(ValueError, mod.bisect_right, [1, 2, 3], 5, -1, 3) self.assertRaises(ValueError, mod.insort_left, [1, 2, 3], 5, -1, 3) self.assertRaises(ValueError, mod.insort_right, [1, 2, 3], 5, -1, 3) def test_large_range(self): # Issue 13496 mod = self.module n = sys.maxsize data = range(n-1) self.assertEqual(mod.bisect_left(data, n-3), n-3) self.assertEqual(mod.bisect_right(data, n-3), n-2) self.assertEqual(mod.bisect_left(data, n-3, n-10, n), n-3) self.assertEqual(mod.bisect_right(data, n-3, n-10, n), n-2) def test_large_pyrange(self): # Same as above, but without C-imposed limits on range() parameters mod = self.module n = sys.maxsize data = Range(0, n-1) self.assertEqual(mod.bisect_left(data, n-3), n-3) self.assertEqual(mod.bisect_right(data, n-3), n-2) self.assertEqual(mod.bisect_left(data, n-3, n-10, n), n-3) self.assertEqual(mod.bisect_right(data, n-3, n-10, n), n-2) x = n - 100 mod.insort_left(data, x, x - 50, x + 50) self.assertEqual(data.last_insert, (x, x)) x = n - 200 mod.insort_right(data, x, x - 50, x + 50) self.assertEqual(data.last_insert, (x + 1, x)) def test_random(self, n=25): from random import randrange for i in range(n): data = [randrange(0, n, 2) for j in range(i)] data.sort() elem = randrange(-1, n+1) ip = self.module.bisect_left(data, elem) if ip < len(data): self.assertTrue(elem <= data[ip]) if ip > 0: self.assertTrue(data[ip-1] < elem) ip = self.module.bisect_right(data, elem) if ip < len(data): self.assertTrue(elem < data[ip]) if ip > 0: self.assertTrue(data[ip-1] <= elem) def test_optionalSlicing(self): for func, data, elem, expected in self.precomputedCases: for lo in range(4): lo = min(len(data), lo) for hi in range(3,8): hi = min(len(data), hi) ip = func(data, elem, lo, hi) self.assertTrue(lo <= ip <= hi) if func is self.module.bisect_left and ip < hi: self.assertTrue(elem <= data[ip]) if func is self.module.bisect_left and ip > lo: self.assertTrue(data[ip-1] < elem) if func is self.module.bisect_right and ip < hi: self.assertTrue(elem < data[ip]) if func is self.module.bisect_right and ip > lo: self.assertTrue(data[ip-1] <= elem) self.assertEqual(ip, max(lo, min(hi, expected))) def test_backcompatibility(self): self.assertEqual(self.module.bisect, self.module.bisect_right) def test_keyword_args(self): data = [10, 20, 30, 40, 50] self.assertEqual(self.module.bisect_left(a=data, x=25, lo=1, hi=3), 2) self.assertEqual(self.module.bisect_right(a=data, x=25, lo=1, hi=3), 2) self.assertEqual(self.module.bisect(a=data, x=25, lo=1, hi=3), 2) self.module.insort_left(a=data, x=25, lo=1, hi=3) self.module.insort_right(a=data, x=25, lo=1, hi=3) self.module.insort(a=data, x=25, lo=1, hi=3) self.assertEqual(data, [10, 20, 25, 25, 25, 30, 40, 50]) def test_lookups_with_key_function(self): mod = self.module # Invariant: Index with a keyfunc on an array # should match the index on an array where # key function has already been applied. keyfunc = abs arr = sorted([2, -4, 6, 8, -10], key=keyfunc) precomputed_arr = list(map(keyfunc, arr)) for x in precomputed_arr: self.assertEqual( mod.bisect_left(arr, x, key=keyfunc), mod.bisect_left(precomputed_arr, x) ) self.assertEqual( mod.bisect_right(arr, x, key=keyfunc), mod.bisect_right(precomputed_arr, x) ) keyfunc = str.casefold arr = sorted('aBcDeEfgHhiIiij', key=keyfunc) precomputed_arr = list(map(keyfunc, arr)) for x in precomputed_arr: self.assertEqual( mod.bisect_left(arr, x, key=keyfunc), mod.bisect_left(precomputed_arr, x) ) self.assertEqual( mod.bisect_right(arr, x, key=keyfunc), mod.bisect_right(precomputed_arr, x) ) def test_insort(self): from random import shuffle mod = self.module # Invariant: As random elements are inserted in # a target list, the targetlist remains sorted. keyfunc = abs data = list(range(-10, 11)) + list(range(-20, 20, 2)) shuffle(data) target = [] for x in data: mod.insort_left(target, x, key=keyfunc) self.assertEqual( sorted(target, key=keyfunc), target ) target = [] for x in data: mod.insort_right(target, x, key=keyfunc) self.assertEqual( sorted(target, key=keyfunc), target ) def test_insort_keynotNone(self): x = [] y = {"a": 2, "b": 1} for f in (self.module.insort_left, self.module.insort_right): self.assertRaises(TypeError, f, x, y, key = "b") class TestBisectPython(TestBisect, unittest.TestCase): module = py_bisect class TestBisectC(TestBisect, unittest.TestCase): module = c_bisect #============================================================================== class TestInsort: def test_vsBuiltinSort(self, n=500): from random import choice for insorted in (list(), UserList()): for i in range(n): digit = choice("0123456789") if digit in "02468": f = self.module.insort_left else: f = self.module.insort_right f(insorted, digit) self.assertEqual(sorted(insorted), insorted) def test_backcompatibility(self): self.assertEqual(self.module.insort, self.module.insort_right) def test_listDerived(self): class List(list): data = [] def insert(self, index, item): self.data.insert(index, item) lst = List() self.module.insort_left(lst, 10) self.module.insort_right(lst, 5) self.assertEqual([5, 10], lst.data) class TestInsortPython(TestInsort, unittest.TestCase): module = py_bisect class TestInsortC(TestInsort, unittest.TestCase): module = c_bisect #============================================================================== class LenOnly: "Dummy sequence class defining __len__ but not __getitem__." def __len__(self): return 10 class GetOnly: "Dummy sequence class defining __getitem__ but not __len__." def __getitem__(self, ndx): return 10 class CmpErr: "Dummy element that always raises an error during comparison" def __lt__(self, other): raise ZeroDivisionError __gt__ = __lt__ __le__ = __lt__ __ge__ = __lt__ __eq__ = __lt__ __ne__ = __lt__ class TestErrorHandling: def test_non_sequence(self): for f in (self.module.bisect_left, self.module.bisect_right, self.module.insort_left, self.module.insort_right): self.assertRaises(TypeError, f, 10, 10) def test_len_only(self): for f in (self.module.bisect_left, self.module.bisect_right, self.module.insort_left, self.module.insort_right): self.assertRaises(TypeError, f, LenOnly(), 10) def test_get_only(self): for f in (self.module.bisect_left, self.module.bisect_right, self.module.insort_left, self.module.insort_right): self.assertRaises(TypeError, f, GetOnly(), 10) def test_cmp_err(self): seq = [CmpErr(), CmpErr(), CmpErr()] for f in (self.module.bisect_left, self.module.bisect_right, self.module.insort_left, self.module.insort_right): self.assertRaises(ZeroDivisionError, f, seq, 10) def test_arg_parsing(self): for f in (self.module.bisect_left, self.module.bisect_right, self.module.insort_left, self.module.insort_right): self.assertRaises(TypeError, f, 10) class TestErrorHandlingPython(TestErrorHandling, unittest.TestCase): module = py_bisect class TestErrorHandlingC(TestErrorHandling, unittest.TestCase): module = c_bisect #============================================================================== class TestDocExample: def test_grades(self): def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'): i = self.module.bisect(breakpoints, score) return grades[i] result = [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]] self.assertEqual(result, ['F', 'A', 'C', 'C', 'B', 'A', 'A']) def test_colors(self): data = [('red', 5), ('blue', 1), ('yellow', 8), ('black', 0)] data.sort(key=lambda r: r[1]) keys = [r[1] for r in data] bisect_left = self.module.bisect_left self.assertEqual(data[bisect_left(keys, 0)], ('black', 0)) self.assertEqual(data[bisect_left(keys, 1)], ('blue', 1)) self.assertEqual(data[bisect_left(keys, 5)], ('red', 5)) self.assertEqual(data[bisect_left(keys, 8)], ('yellow', 8)) class TestDocExamplePython(TestDocExample, unittest.TestCase): module = py_bisect class TestDocExampleC(TestDocExample, unittest.TestCase): module = c_bisect #------------------------------------------------------------------------------ if __name__ == "__main__": unittest.main()