Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 1 | import sys |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 2 | import unittest |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 3 | from test import support |
Raymond Hettinger | 53dbe39 | 2008-02-12 20:03:09 +0000 | [diff] [blame] | 4 | from collections import UserList |
Tim Peters | 36cdad1 | 2000-12-29 02:06:45 +0000 | [diff] [blame] | 5 | |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 6 | # We do a bit of trickery here to be able to test both the C implementation |
| 7 | # and the Python implementation of the module. |
| 8 | |
| 9 | # Make it impossible to import the C implementation anymore. |
| 10 | sys.modules['_bisect'] = 0 |
| 11 | # We must also handle the case that bisect was imported before. |
| 12 | if 'bisect' in sys.modules: |
| 13 | del sys.modules['bisect'] |
| 14 | |
| 15 | # Now we can import the module and get the pure Python implementation. |
| 16 | import bisect as py_bisect |
| 17 | |
| 18 | # Restore everything to normal. |
| 19 | del sys.modules['_bisect'] |
| 20 | del sys.modules['bisect'] |
| 21 | |
| 22 | # This is now the module with the C implementation. |
| 23 | import bisect as c_bisect |
| 24 | |
| 25 | |
Antoine Pitrou | fb5b954 | 2012-05-16 15:01:40 +0200 | [diff] [blame] | 26 | class Range(object): |
| 27 | """A trivial range()-like object without any integer width limitations.""" |
| 28 | def __init__(self, start, stop): |
| 29 | self.start = start |
| 30 | self.stop = stop |
| 31 | self.last_insert = None |
| 32 | |
| 33 | def __len__(self): |
| 34 | return self.stop - self.start |
| 35 | |
| 36 | def __getitem__(self, idx): |
| 37 | n = self.stop - self.start |
| 38 | if idx < 0: |
| 39 | idx += n |
| 40 | if idx >= n: |
| 41 | raise IndexError(idx) |
| 42 | return self.start + idx |
| 43 | |
| 44 | def insert(self, idx, item): |
| 45 | self.last_insert = idx, item |
| 46 | |
| 47 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 48 | class TestBisect(unittest.TestCase): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 49 | module = None |
Tim Peters | 36cdad1 | 2000-12-29 02:06:45 +0000 | [diff] [blame] | 50 | |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 51 | def setUp(self): |
| 52 | self.precomputedCases = [ |
| 53 | (self.module.bisect_right, [], 1, 0), |
| 54 | (self.module.bisect_right, [1], 0, 0), |
| 55 | (self.module.bisect_right, [1], 1, 1), |
| 56 | (self.module.bisect_right, [1], 2, 1), |
| 57 | (self.module.bisect_right, [1, 1], 0, 0), |
| 58 | (self.module.bisect_right, [1, 1], 1, 2), |
| 59 | (self.module.bisect_right, [1, 1], 2, 2), |
| 60 | (self.module.bisect_right, [1, 1, 1], 0, 0), |
| 61 | (self.module.bisect_right, [1, 1, 1], 1, 3), |
| 62 | (self.module.bisect_right, [1, 1, 1], 2, 3), |
| 63 | (self.module.bisect_right, [1, 1, 1, 1], 0, 0), |
| 64 | (self.module.bisect_right, [1, 1, 1, 1], 1, 4), |
| 65 | (self.module.bisect_right, [1, 1, 1, 1], 2, 4), |
| 66 | (self.module.bisect_right, [1, 2], 0, 0), |
| 67 | (self.module.bisect_right, [1, 2], 1, 1), |
| 68 | (self.module.bisect_right, [1, 2], 1.5, 1), |
| 69 | (self.module.bisect_right, [1, 2], 2, 2), |
| 70 | (self.module.bisect_right, [1, 2], 3, 2), |
| 71 | (self.module.bisect_right, [1, 1, 2, 2], 0, 0), |
| 72 | (self.module.bisect_right, [1, 1, 2, 2], 1, 2), |
| 73 | (self.module.bisect_right, [1, 1, 2, 2], 1.5, 2), |
| 74 | (self.module.bisect_right, [1, 1, 2, 2], 2, 4), |
| 75 | (self.module.bisect_right, [1, 1, 2, 2], 3, 4), |
| 76 | (self.module.bisect_right, [1, 2, 3], 0, 0), |
| 77 | (self.module.bisect_right, [1, 2, 3], 1, 1), |
| 78 | (self.module.bisect_right, [1, 2, 3], 1.5, 1), |
| 79 | (self.module.bisect_right, [1, 2, 3], 2, 2), |
| 80 | (self.module.bisect_right, [1, 2, 3], 2.5, 2), |
| 81 | (self.module.bisect_right, [1, 2, 3], 3, 3), |
| 82 | (self.module.bisect_right, [1, 2, 3], 4, 3), |
| 83 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0), |
| 84 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 1), |
| 85 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1), |
| 86 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 3), |
| 87 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3), |
| 88 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 6), |
| 89 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6), |
| 90 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 10), |
| 91 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10), |
Tim Peters | 36cdad1 | 2000-12-29 02:06:45 +0000 | [diff] [blame] | 92 | |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 93 | (self.module.bisect_left, [], 1, 0), |
| 94 | (self.module.bisect_left, [1], 0, 0), |
| 95 | (self.module.bisect_left, [1], 1, 0), |
| 96 | (self.module.bisect_left, [1], 2, 1), |
| 97 | (self.module.bisect_left, [1, 1], 0, 0), |
| 98 | (self.module.bisect_left, [1, 1], 1, 0), |
| 99 | (self.module.bisect_left, [1, 1], 2, 2), |
| 100 | (self.module.bisect_left, [1, 1, 1], 0, 0), |
| 101 | (self.module.bisect_left, [1, 1, 1], 1, 0), |
| 102 | (self.module.bisect_left, [1, 1, 1], 2, 3), |
| 103 | (self.module.bisect_left, [1, 1, 1, 1], 0, 0), |
| 104 | (self.module.bisect_left, [1, 1, 1, 1], 1, 0), |
| 105 | (self.module.bisect_left, [1, 1, 1, 1], 2, 4), |
| 106 | (self.module.bisect_left, [1, 2], 0, 0), |
| 107 | (self.module.bisect_left, [1, 2], 1, 0), |
| 108 | (self.module.bisect_left, [1, 2], 1.5, 1), |
| 109 | (self.module.bisect_left, [1, 2], 2, 1), |
| 110 | (self.module.bisect_left, [1, 2], 3, 2), |
| 111 | (self.module.bisect_left, [1, 1, 2, 2], 0, 0), |
| 112 | (self.module.bisect_left, [1, 1, 2, 2], 1, 0), |
| 113 | (self.module.bisect_left, [1, 1, 2, 2], 1.5, 2), |
| 114 | (self.module.bisect_left, [1, 1, 2, 2], 2, 2), |
| 115 | (self.module.bisect_left, [1, 1, 2, 2], 3, 4), |
| 116 | (self.module.bisect_left, [1, 2, 3], 0, 0), |
| 117 | (self.module.bisect_left, [1, 2, 3], 1, 0), |
| 118 | (self.module.bisect_left, [1, 2, 3], 1.5, 1), |
| 119 | (self.module.bisect_left, [1, 2, 3], 2, 1), |
| 120 | (self.module.bisect_left, [1, 2, 3], 2.5, 2), |
| 121 | (self.module.bisect_left, [1, 2, 3], 3, 2), |
| 122 | (self.module.bisect_left, [1, 2, 3], 4, 3), |
| 123 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0), |
| 124 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 0), |
| 125 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1), |
| 126 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 1), |
| 127 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3), |
| 128 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 3), |
| 129 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6), |
| 130 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 6), |
| 131 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10) |
| 132 | ] |
Tim Peters | 36cdad1 | 2000-12-29 02:06:45 +0000 | [diff] [blame] | 133 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 134 | def test_precomputed(self): |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 135 | for func, data, elem, expected in self.precomputedCases: |
| 136 | self.assertEqual(func(data, elem), expected) |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 137 | self.assertEqual(func(UserList(data), elem), expected) |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 138 | |
Georg Brandl | 2ee470f | 2008-07-16 12:55:28 +0000 | [diff] [blame] | 139 | def test_negative_lo(self): |
| 140 | # Issue 3301 |
| 141 | mod = self.module |
| 142 | self.assertRaises(ValueError, mod.bisect_left, [1, 2, 3], 5, -1, 3), |
| 143 | self.assertRaises(ValueError, mod.bisect_right, [1, 2, 3], 5, -1, 3), |
| 144 | self.assertRaises(ValueError, mod.insort_left, [1, 2, 3], 5, -1, 3), |
| 145 | self.assertRaises(ValueError, mod.insort_right, [1, 2, 3], 5, -1, 3), |
| 146 | |
Mark Dickinson | a13b109 | 2012-04-15 16:30:35 +0100 | [diff] [blame] | 147 | def test_large_range(self): |
| 148 | # Issue 13496 |
| 149 | mod = self.module |
Antoine Pitrou | fb5b954 | 2012-05-16 15:01:40 +0200 | [diff] [blame] | 150 | n = sys.maxsize |
| 151 | data = range(n-1) |
| 152 | self.assertEqual(mod.bisect_left(data, n-3), n-3) |
| 153 | self.assertEqual(mod.bisect_right(data, n-3), n-2) |
| 154 | self.assertEqual(mod.bisect_left(data, n-3, n-10, n), n-3) |
| 155 | self.assertEqual(mod.bisect_right(data, n-3, n-10, n), n-2) |
| 156 | |
| 157 | def test_large_pyrange(self): |
| 158 | # Same as above, but without C-imposed limits on range() parameters |
| 159 | mod = self.module |
| 160 | n = sys.maxsize |
| 161 | data = Range(0, n-1) |
| 162 | self.assertEqual(mod.bisect_left(data, n-3), n-3) |
| 163 | self.assertEqual(mod.bisect_right(data, n-3), n-2) |
| 164 | self.assertEqual(mod.bisect_left(data, n-3, n-10, n), n-3) |
| 165 | self.assertEqual(mod.bisect_right(data, n-3, n-10, n), n-2) |
| 166 | x = n - 100 |
| 167 | mod.insort_left(data, x, x - 50, x + 50) |
| 168 | self.assertEqual(data.last_insert, (x, x)) |
| 169 | x = n - 200 |
| 170 | mod.insort_right(data, x, x - 50, x + 50) |
| 171 | self.assertEqual(data.last_insert, (x + 1, x)) |
Mark Dickinson | a13b109 | 2012-04-15 16:30:35 +0100 | [diff] [blame] | 172 | |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 173 | def test_random(self, n=25): |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 174 | from random import randrange |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 175 | for i in range(n): |
| 176 | data = [randrange(0, n, 2) for j in range(i)] |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 177 | data.sort() |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 178 | elem = randrange(-1, n+1) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 179 | ip = self.module.bisect_left(data, elem) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 180 | if ip < len(data): |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 181 | self.assertTrue(elem <= data[ip]) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 182 | if ip > 0: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 183 | self.assertTrue(data[ip-1] < elem) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 184 | ip = self.module.bisect_right(data, elem) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 185 | if ip < len(data): |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 186 | self.assertTrue(elem < data[ip]) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 187 | if ip > 0: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 188 | self.assertTrue(data[ip-1] <= elem) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 189 | |
Raymond Hettinger | a9f18dc | 2003-01-16 13:02:25 +0000 | [diff] [blame] | 190 | def test_optionalSlicing(self): |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 191 | for func, data, elem, expected in self.precomputedCases: |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 192 | for lo in range(4): |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 193 | lo = min(len(data), lo) |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 194 | for hi in range(3,8): |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 195 | hi = min(len(data), hi) |
| 196 | ip = func(data, elem, lo, hi) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 197 | self.assertTrue(lo <= ip <= hi) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 198 | if func is self.module.bisect_left and ip < hi: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 199 | self.assertTrue(elem <= data[ip]) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 200 | if func is self.module.bisect_left and ip > lo: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 201 | self.assertTrue(data[ip-1] < elem) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 202 | if func is self.module.bisect_right and ip < hi: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 203 | self.assertTrue(elem < data[ip]) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 204 | if func is self.module.bisect_right and ip > lo: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 205 | self.assertTrue(data[ip-1] <= elem) |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 206 | self.assertEqual(ip, max(lo, min(hi, expected))) |
Raymond Hettinger | a9f18dc | 2003-01-16 13:02:25 +0000 | [diff] [blame] | 207 | |
| 208 | def test_backcompatibility(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 209 | self.assertEqual(self.module.bisect, self.module.bisect_right) |
Raymond Hettinger | a9f18dc | 2003-01-16 13:02:25 +0000 | [diff] [blame] | 210 | |
Raymond Hettinger | cc9a951 | 2005-10-05 11:39:12 +0000 | [diff] [blame] | 211 | def test_keyword_args(self): |
| 212 | data = [10, 20, 30, 40, 50] |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 213 | self.assertEqual(self.module.bisect_left(a=data, x=25, lo=1, hi=3), 2) |
| 214 | self.assertEqual(self.module.bisect_right(a=data, x=25, lo=1, hi=3), 2) |
| 215 | self.assertEqual(self.module.bisect(a=data, x=25, lo=1, hi=3), 2) |
| 216 | self.module.insort_left(a=data, x=25, lo=1, hi=3) |
| 217 | self.module.insort_right(a=data, x=25, lo=1, hi=3) |
| 218 | self.module.insort(a=data, x=25, lo=1, hi=3) |
Raymond Hettinger | cc9a951 | 2005-10-05 11:39:12 +0000 | [diff] [blame] | 219 | self.assertEqual(data, [10, 20, 25, 25, 25, 30, 40, 50]) |
| 220 | |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 221 | class TestBisectPython(TestBisect): |
| 222 | module = py_bisect |
| 223 | |
| 224 | class TestBisectC(TestBisect): |
| 225 | module = c_bisect |
| 226 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 227 | #============================================================================== |
| 228 | |
| 229 | class TestInsort(unittest.TestCase): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 230 | module = None |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 231 | |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 232 | def test_vsBuiltinSort(self, n=500): |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 233 | from random import choice |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 234 | for insorted in (list(), UserList()): |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 235 | for i in range(n): |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 236 | digit = choice("0123456789") |
| 237 | if digit in "02468": |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 238 | f = self.module.insort_left |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 239 | else: |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 240 | f = self.module.insort_right |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 241 | f(insorted, digit) |
| 242 | self.assertEqual(sorted(insorted), insorted) |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 243 | |
Raymond Hettinger | a9f18dc | 2003-01-16 13:02:25 +0000 | [diff] [blame] | 244 | def test_backcompatibility(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 245 | self.assertEqual(self.module.insort, self.module.insort_right) |
| 246 | |
Benjamin Peterson | f10a79a | 2008-10-11 00:49:57 +0000 | [diff] [blame] | 247 | def test_listDerived(self): |
| 248 | class List(list): |
| 249 | data = [] |
| 250 | def insert(self, index, item): |
| 251 | self.data.insert(index, item) |
| 252 | |
| 253 | lst = List() |
| 254 | self.module.insort_left(lst, 10) |
| 255 | self.module.insort_right(lst, 5) |
| 256 | self.assertEqual([5, 10], lst.data) |
| 257 | |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 258 | class TestInsortPython(TestInsort): |
| 259 | module = py_bisect |
| 260 | |
| 261 | class TestInsortC(TestInsort): |
| 262 | module = c_bisect |
Raymond Hettinger | a9f18dc | 2003-01-16 13:02:25 +0000 | [diff] [blame] | 263 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 264 | #============================================================================== |
| 265 | |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 266 | |
| 267 | class LenOnly: |
| 268 | "Dummy sequence class defining __len__ but not __getitem__." |
| 269 | def __len__(self): |
| 270 | return 10 |
| 271 | |
| 272 | class GetOnly: |
| 273 | "Dummy sequence class defining __getitem__ but not __len__." |
| 274 | def __getitem__(self, ndx): |
| 275 | return 10 |
| 276 | |
| 277 | class CmpErr: |
| 278 | "Dummy element that always raises an error during comparison" |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 279 | def __lt__(self, other): |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 280 | raise ZeroDivisionError |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 281 | __gt__ = __lt__ |
| 282 | __le__ = __lt__ |
| 283 | __ge__ = __lt__ |
| 284 | __eq__ = __lt__ |
| 285 | __ne__ = __lt__ |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 286 | |
| 287 | class TestErrorHandling(unittest.TestCase): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 288 | module = None |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 289 | |
| 290 | def test_non_sequence(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 291 | for f in (self.module.bisect_left, self.module.bisect_right, |
| 292 | self.module.insort_left, self.module.insort_right): |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 293 | self.assertRaises(TypeError, f, 10, 10) |
| 294 | |
| 295 | def test_len_only(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 296 | for f in (self.module.bisect_left, self.module.bisect_right, |
| 297 | self.module.insort_left, self.module.insort_right): |
Thomas Wouters | 1ae9afa | 2006-04-15 09:12:14 +0000 | [diff] [blame] | 298 | self.assertRaises(TypeError, f, LenOnly(), 10) |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 299 | |
| 300 | def test_get_only(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 301 | for f in (self.module.bisect_left, self.module.bisect_right, |
| 302 | self.module.insort_left, self.module.insort_right): |
Thomas Wouters | 1ae9afa | 2006-04-15 09:12:14 +0000 | [diff] [blame] | 303 | self.assertRaises(TypeError, f, GetOnly(), 10) |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 304 | |
Raymond Hettinger | 630e535 | 2004-09-27 23:11:35 +0000 | [diff] [blame] | 305 | def test_cmp_err(self): |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 306 | seq = [CmpErr(), CmpErr(), CmpErr()] |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 307 | for f in (self.module.bisect_left, self.module.bisect_right, |
| 308 | self.module.insort_left, self.module.insort_right): |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 309 | self.assertRaises(ZeroDivisionError, f, seq, 10) |
| 310 | |
| 311 | def test_arg_parsing(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 312 | for f in (self.module.bisect_left, self.module.bisect_right, |
| 313 | self.module.insort_left, self.module.insort_right): |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 314 | self.assertRaises(TypeError, f, 10) |
| 315 | |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 316 | class TestErrorHandlingPython(TestErrorHandling): |
| 317 | module = py_bisect |
| 318 | |
| 319 | class TestErrorHandlingC(TestErrorHandling): |
| 320 | module = c_bisect |
| 321 | |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 322 | #============================================================================== |
| 323 | |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 324 | libreftest = """ |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 325 | Example from the Library Reference: Doc/library/bisect.rst |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 326 | |
| 327 | The bisect() function is generally useful for categorizing numeric data. |
| 328 | This example uses bisect() to look up a letter grade for an exam total |
| 329 | (say) based on a set of ordered numeric breakpoints: 85 and up is an `A', |
| 330 | 75..84 is a `B', etc. |
| 331 | |
| 332 | >>> grades = "FEDCBA" |
| 333 | >>> breakpoints = [30, 44, 66, 75, 85] |
| 334 | >>> from bisect import bisect |
| 335 | >>> def grade(total): |
| 336 | ... return grades[bisect(breakpoints, total)] |
| 337 | ... |
| 338 | >>> grade(66) |
| 339 | 'C' |
Guido van Rossum | c1f779c | 2007-07-03 08:25:58 +0000 | [diff] [blame] | 340 | >>> list(map(grade, [33, 99, 77, 44, 12, 88])) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 341 | ['E', 'A', 'B', 'D', 'F', 'A'] |
| 342 | |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 343 | """ |
| 344 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 345 | #------------------------------------------------------------------------------ |
| 346 | |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 347 | __test__ = {'libreftest' : libreftest} |
| 348 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 349 | def test_main(verbose=None): |
| 350 | from test import test_bisect |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 351 | |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 352 | test_classes = [TestBisectPython, TestBisectC, |
| 353 | TestInsortPython, TestInsortC, |
| 354 | TestErrorHandlingPython, TestErrorHandlingC] |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 355 | |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 356 | support.run_unittest(*test_classes) |
| 357 | support.run_doctest(test_bisect, verbose) |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 358 | |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 359 | # verify reference counting |
| 360 | if verbose and hasattr(sys, "gettotalrefcount"): |
| 361 | import gc |
| 362 | counts = [None] * 5 |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 363 | for i in range(len(counts)): |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 364 | support.run_unittest(*test_classes) |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 365 | gc.collect() |
| 366 | counts[i] = sys.gettotalrefcount() |
Guido van Rossum | be19ed7 | 2007-02-09 05:37:30 +0000 | [diff] [blame] | 367 | print(counts) |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 368 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 369 | if __name__ == "__main__": |
| 370 | test_main(verbose=True) |