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 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 6 | py_bisect = support.import_fresh_module('bisect', blocked=['_bisect']) |
| 7 | c_bisect = support.import_fresh_module('bisect', fresh=['_bisect']) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 8 | |
Antoine Pitrou | fb5b954 | 2012-05-16 15:01:40 +0200 | [diff] [blame] | 9 | class Range(object): |
Brett Cannon | a66c2ee | 2013-01-27 18:58:20 -0500 | [diff] [blame] | 10 | """A trivial range()-like object that has an insert() method.""" |
Antoine Pitrou | fb5b954 | 2012-05-16 15:01:40 +0200 | [diff] [blame] | 11 | def __init__(self, start, stop): |
| 12 | self.start = start |
| 13 | self.stop = stop |
| 14 | self.last_insert = None |
| 15 | |
| 16 | def __len__(self): |
| 17 | return self.stop - self.start |
| 18 | |
| 19 | def __getitem__(self, idx): |
| 20 | n = self.stop - self.start |
| 21 | if idx < 0: |
| 22 | idx += n |
| 23 | if idx >= n: |
| 24 | raise IndexError(idx) |
| 25 | return self.start + idx |
| 26 | |
| 27 | def insert(self, idx, item): |
| 28 | self.last_insert = idx, item |
| 29 | |
| 30 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 31 | class TestBisect: |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 32 | def setUp(self): |
| 33 | self.precomputedCases = [ |
| 34 | (self.module.bisect_right, [], 1, 0), |
| 35 | (self.module.bisect_right, [1], 0, 0), |
| 36 | (self.module.bisect_right, [1], 1, 1), |
| 37 | (self.module.bisect_right, [1], 2, 1), |
| 38 | (self.module.bisect_right, [1, 1], 0, 0), |
| 39 | (self.module.bisect_right, [1, 1], 1, 2), |
| 40 | (self.module.bisect_right, [1, 1], 2, 2), |
| 41 | (self.module.bisect_right, [1, 1, 1], 0, 0), |
| 42 | (self.module.bisect_right, [1, 1, 1], 1, 3), |
| 43 | (self.module.bisect_right, [1, 1, 1], 2, 3), |
| 44 | (self.module.bisect_right, [1, 1, 1, 1], 0, 0), |
| 45 | (self.module.bisect_right, [1, 1, 1, 1], 1, 4), |
| 46 | (self.module.bisect_right, [1, 1, 1, 1], 2, 4), |
| 47 | (self.module.bisect_right, [1, 2], 0, 0), |
| 48 | (self.module.bisect_right, [1, 2], 1, 1), |
| 49 | (self.module.bisect_right, [1, 2], 1.5, 1), |
| 50 | (self.module.bisect_right, [1, 2], 2, 2), |
| 51 | (self.module.bisect_right, [1, 2], 3, 2), |
| 52 | (self.module.bisect_right, [1, 1, 2, 2], 0, 0), |
| 53 | (self.module.bisect_right, [1, 1, 2, 2], 1, 2), |
| 54 | (self.module.bisect_right, [1, 1, 2, 2], 1.5, 2), |
| 55 | (self.module.bisect_right, [1, 1, 2, 2], 2, 4), |
| 56 | (self.module.bisect_right, [1, 1, 2, 2], 3, 4), |
| 57 | (self.module.bisect_right, [1, 2, 3], 0, 0), |
| 58 | (self.module.bisect_right, [1, 2, 3], 1, 1), |
| 59 | (self.module.bisect_right, [1, 2, 3], 1.5, 1), |
| 60 | (self.module.bisect_right, [1, 2, 3], 2, 2), |
| 61 | (self.module.bisect_right, [1, 2, 3], 2.5, 2), |
| 62 | (self.module.bisect_right, [1, 2, 3], 3, 3), |
| 63 | (self.module.bisect_right, [1, 2, 3], 4, 3), |
| 64 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0), |
| 65 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 1), |
| 66 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1), |
| 67 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 3), |
| 68 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3), |
| 69 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 6), |
| 70 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6), |
| 71 | (self.module.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 10), |
| 72 | (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] | 73 | |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 74 | (self.module.bisect_left, [], 1, 0), |
| 75 | (self.module.bisect_left, [1], 0, 0), |
| 76 | (self.module.bisect_left, [1], 1, 0), |
| 77 | (self.module.bisect_left, [1], 2, 1), |
| 78 | (self.module.bisect_left, [1, 1], 0, 0), |
| 79 | (self.module.bisect_left, [1, 1], 1, 0), |
| 80 | (self.module.bisect_left, [1, 1], 2, 2), |
| 81 | (self.module.bisect_left, [1, 1, 1], 0, 0), |
| 82 | (self.module.bisect_left, [1, 1, 1], 1, 0), |
| 83 | (self.module.bisect_left, [1, 1, 1], 2, 3), |
| 84 | (self.module.bisect_left, [1, 1, 1, 1], 0, 0), |
| 85 | (self.module.bisect_left, [1, 1, 1, 1], 1, 0), |
| 86 | (self.module.bisect_left, [1, 1, 1, 1], 2, 4), |
| 87 | (self.module.bisect_left, [1, 2], 0, 0), |
| 88 | (self.module.bisect_left, [1, 2], 1, 0), |
| 89 | (self.module.bisect_left, [1, 2], 1.5, 1), |
| 90 | (self.module.bisect_left, [1, 2], 2, 1), |
| 91 | (self.module.bisect_left, [1, 2], 3, 2), |
| 92 | (self.module.bisect_left, [1, 1, 2, 2], 0, 0), |
| 93 | (self.module.bisect_left, [1, 1, 2, 2], 1, 0), |
| 94 | (self.module.bisect_left, [1, 1, 2, 2], 1.5, 2), |
| 95 | (self.module.bisect_left, [1, 1, 2, 2], 2, 2), |
| 96 | (self.module.bisect_left, [1, 1, 2, 2], 3, 4), |
| 97 | (self.module.bisect_left, [1, 2, 3], 0, 0), |
| 98 | (self.module.bisect_left, [1, 2, 3], 1, 0), |
| 99 | (self.module.bisect_left, [1, 2, 3], 1.5, 1), |
| 100 | (self.module.bisect_left, [1, 2, 3], 2, 1), |
| 101 | (self.module.bisect_left, [1, 2, 3], 2.5, 2), |
| 102 | (self.module.bisect_left, [1, 2, 3], 3, 2), |
| 103 | (self.module.bisect_left, [1, 2, 3], 4, 3), |
| 104 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0), |
| 105 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 0), |
| 106 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1), |
| 107 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 1), |
| 108 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3), |
| 109 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 3), |
| 110 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6), |
| 111 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 6), |
| 112 | (self.module.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10) |
| 113 | ] |
Tim Peters | 36cdad1 | 2000-12-29 02:06:45 +0000 | [diff] [blame] | 114 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 115 | def test_precomputed(self): |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 116 | for func, data, elem, expected in self.precomputedCases: |
| 117 | self.assertEqual(func(data, elem), expected) |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 118 | self.assertEqual(func(UserList(data), elem), expected) |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 119 | |
Georg Brandl | 2ee470f | 2008-07-16 12:55:28 +0000 | [diff] [blame] | 120 | def test_negative_lo(self): |
| 121 | # Issue 3301 |
| 122 | mod = self.module |
Victor Stinner | 3fa1aae | 2013-03-26 01:14:08 +0100 | [diff] [blame] | 123 | self.assertRaises(ValueError, mod.bisect_left, [1, 2, 3], 5, -1, 3) |
| 124 | self.assertRaises(ValueError, mod.bisect_right, [1, 2, 3], 5, -1, 3) |
| 125 | self.assertRaises(ValueError, mod.insort_left, [1, 2, 3], 5, -1, 3) |
| 126 | self.assertRaises(ValueError, mod.insort_right, [1, 2, 3], 5, -1, 3) |
Georg Brandl | 2ee470f | 2008-07-16 12:55:28 +0000 | [diff] [blame] | 127 | |
Mark Dickinson | a13b109 | 2012-04-15 16:30:35 +0100 | [diff] [blame] | 128 | def test_large_range(self): |
| 129 | # Issue 13496 |
| 130 | mod = self.module |
Antoine Pitrou | fb5b954 | 2012-05-16 15:01:40 +0200 | [diff] [blame] | 131 | n = sys.maxsize |
| 132 | data = range(n-1) |
| 133 | self.assertEqual(mod.bisect_left(data, n-3), n-3) |
| 134 | self.assertEqual(mod.bisect_right(data, n-3), n-2) |
| 135 | self.assertEqual(mod.bisect_left(data, n-3, n-10, n), n-3) |
| 136 | self.assertEqual(mod.bisect_right(data, n-3, n-10, n), n-2) |
| 137 | |
| 138 | def test_large_pyrange(self): |
| 139 | # Same as above, but without C-imposed limits on range() parameters |
| 140 | mod = self.module |
| 141 | n = sys.maxsize |
| 142 | data = Range(0, n-1) |
| 143 | self.assertEqual(mod.bisect_left(data, n-3), n-3) |
| 144 | self.assertEqual(mod.bisect_right(data, n-3), n-2) |
| 145 | self.assertEqual(mod.bisect_left(data, n-3, n-10, n), n-3) |
| 146 | self.assertEqual(mod.bisect_right(data, n-3, n-10, n), n-2) |
| 147 | x = n - 100 |
| 148 | mod.insort_left(data, x, x - 50, x + 50) |
| 149 | self.assertEqual(data.last_insert, (x, x)) |
| 150 | x = n - 200 |
| 151 | mod.insort_right(data, x, x - 50, x + 50) |
| 152 | self.assertEqual(data.last_insert, (x + 1, x)) |
Mark Dickinson | a13b109 | 2012-04-15 16:30:35 +0100 | [diff] [blame] | 153 | |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 154 | def test_random(self, n=25): |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 155 | from random import randrange |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 156 | for i in range(n): |
| 157 | data = [randrange(0, n, 2) for j in range(i)] |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 158 | data.sort() |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 159 | elem = randrange(-1, n+1) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 160 | ip = self.module.bisect_left(data, elem) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 161 | if ip < len(data): |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 162 | self.assertTrue(elem <= data[ip]) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 163 | if ip > 0: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 164 | self.assertTrue(data[ip-1] < elem) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 165 | ip = self.module.bisect_right(data, elem) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 166 | if ip < len(data): |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 167 | self.assertTrue(elem < data[ip]) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 168 | if ip > 0: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 169 | self.assertTrue(data[ip-1] <= elem) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 170 | |
Raymond Hettinger | a9f18dc | 2003-01-16 13:02:25 +0000 | [diff] [blame] | 171 | def test_optionalSlicing(self): |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 172 | for func, data, elem, expected in self.precomputedCases: |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 173 | for lo in range(4): |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 174 | lo = min(len(data), lo) |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 175 | for hi in range(3,8): |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 176 | hi = min(len(data), hi) |
| 177 | ip = func(data, elem, lo, hi) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 178 | self.assertTrue(lo <= ip <= hi) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 179 | if func is self.module.bisect_left and ip < hi: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 180 | self.assertTrue(elem <= data[ip]) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 181 | if func is self.module.bisect_left and ip > lo: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 182 | self.assertTrue(data[ip-1] < elem) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 183 | if func is self.module.bisect_right and ip < hi: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 184 | self.assertTrue(elem < data[ip]) |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 185 | if func is self.module.bisect_right and ip > lo: |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 186 | self.assertTrue(data[ip-1] <= elem) |
Raymond Hettinger | 6aa1c3f | 2003-01-16 14:00:15 +0000 | [diff] [blame] | 187 | self.assertEqual(ip, max(lo, min(hi, expected))) |
Raymond Hettinger | a9f18dc | 2003-01-16 13:02:25 +0000 | [diff] [blame] | 188 | |
| 189 | def test_backcompatibility(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 190 | self.assertEqual(self.module.bisect, self.module.bisect_right) |
Raymond Hettinger | a9f18dc | 2003-01-16 13:02:25 +0000 | [diff] [blame] | 191 | |
Raymond Hettinger | cc9a951 | 2005-10-05 11:39:12 +0000 | [diff] [blame] | 192 | def test_keyword_args(self): |
| 193 | data = [10, 20, 30, 40, 50] |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 194 | self.assertEqual(self.module.bisect_left(a=data, x=25, lo=1, hi=3), 2) |
| 195 | self.assertEqual(self.module.bisect_right(a=data, x=25, lo=1, hi=3), 2) |
| 196 | self.assertEqual(self.module.bisect(a=data, x=25, lo=1, hi=3), 2) |
| 197 | self.module.insort_left(a=data, x=25, lo=1, hi=3) |
| 198 | self.module.insort_right(a=data, x=25, lo=1, hi=3) |
| 199 | self.module.insort(a=data, x=25, lo=1, hi=3) |
Raymond Hettinger | cc9a951 | 2005-10-05 11:39:12 +0000 | [diff] [blame] | 200 | self.assertEqual(data, [10, 20, 25, 25, 25, 30, 40, 50]) |
| 201 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 202 | class TestBisectPython(TestBisect, unittest.TestCase): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 203 | module = py_bisect |
| 204 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 205 | class TestBisectC(TestBisect, unittest.TestCase): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 206 | module = c_bisect |
| 207 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 208 | #============================================================================== |
| 209 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 210 | class TestInsort: |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 211 | def test_vsBuiltinSort(self, n=500): |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 212 | from random import choice |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 213 | for insorted in (list(), UserList()): |
Guido van Rossum | 805365e | 2007-05-07 22:24:25 +0000 | [diff] [blame] | 214 | for i in range(n): |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 215 | digit = choice("0123456789") |
| 216 | if digit in "02468": |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 217 | f = self.module.insort_left |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 218 | else: |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 219 | f = self.module.insort_right |
Raymond Hettinger | 0c41027 | 2004-01-05 10:13:35 +0000 | [diff] [blame] | 220 | f(insorted, digit) |
Andrew Svetlov | eda1f4c | 2012-10-31 22:37:50 +0200 | [diff] [blame] | 221 | self.assertEqual(sorted(insorted), insorted) |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 222 | |
Raymond Hettinger | a9f18dc | 2003-01-16 13:02:25 +0000 | [diff] [blame] | 223 | def test_backcompatibility(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 224 | self.assertEqual(self.module.insort, self.module.insort_right) |
| 225 | |
Benjamin Peterson | f10a79a | 2008-10-11 00:49:57 +0000 | [diff] [blame] | 226 | def test_listDerived(self): |
| 227 | class List(list): |
| 228 | data = [] |
| 229 | def insert(self, index, item): |
| 230 | self.data.insert(index, item) |
| 231 | |
| 232 | lst = List() |
| 233 | self.module.insort_left(lst, 10) |
| 234 | self.module.insort_right(lst, 5) |
| 235 | self.assertEqual([5, 10], lst.data) |
| 236 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 237 | class TestInsortPython(TestInsort, unittest.TestCase): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 238 | module = py_bisect |
| 239 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 240 | class TestInsortC(TestInsort, unittest.TestCase): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 241 | module = c_bisect |
Raymond Hettinger | a9f18dc | 2003-01-16 13:02:25 +0000 | [diff] [blame] | 242 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 243 | #============================================================================== |
| 244 | |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 245 | class LenOnly: |
| 246 | "Dummy sequence class defining __len__ but not __getitem__." |
| 247 | def __len__(self): |
| 248 | return 10 |
| 249 | |
| 250 | class GetOnly: |
| 251 | "Dummy sequence class defining __getitem__ but not __len__." |
| 252 | def __getitem__(self, ndx): |
| 253 | return 10 |
| 254 | |
| 255 | class CmpErr: |
| 256 | "Dummy element that always raises an error during comparison" |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 257 | def __lt__(self, other): |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 258 | raise ZeroDivisionError |
Guido van Rossum | 47b9ff6 | 2006-08-24 00:41:19 +0000 | [diff] [blame] | 259 | __gt__ = __lt__ |
| 260 | __le__ = __lt__ |
| 261 | __ge__ = __lt__ |
| 262 | __eq__ = __lt__ |
| 263 | __ne__ = __lt__ |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 264 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 265 | class TestErrorHandling: |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 266 | def test_non_sequence(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 267 | for f in (self.module.bisect_left, self.module.bisect_right, |
| 268 | self.module.insort_left, self.module.insort_right): |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 269 | self.assertRaises(TypeError, f, 10, 10) |
| 270 | |
| 271 | def test_len_only(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 272 | for f in (self.module.bisect_left, self.module.bisect_right, |
| 273 | self.module.insort_left, self.module.insort_right): |
Thomas Wouters | 1ae9afa | 2006-04-15 09:12:14 +0000 | [diff] [blame] | 274 | self.assertRaises(TypeError, f, LenOnly(), 10) |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 275 | |
| 276 | def test_get_only(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 277 | for f in (self.module.bisect_left, self.module.bisect_right, |
| 278 | self.module.insort_left, self.module.insort_right): |
Thomas Wouters | 1ae9afa | 2006-04-15 09:12:14 +0000 | [diff] [blame] | 279 | self.assertRaises(TypeError, f, GetOnly(), 10) |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 280 | |
Raymond Hettinger | 630e535 | 2004-09-27 23:11:35 +0000 | [diff] [blame] | 281 | def test_cmp_err(self): |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 282 | seq = [CmpErr(), CmpErr(), CmpErr()] |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 283 | for f in (self.module.bisect_left, self.module.bisect_right, |
| 284 | self.module.insort_left, self.module.insort_right): |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 285 | self.assertRaises(ZeroDivisionError, f, seq, 10) |
| 286 | |
| 287 | def test_arg_parsing(self): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 288 | for f in (self.module.bisect_left, self.module.bisect_right, |
| 289 | self.module.insort_left, self.module.insort_right): |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 290 | self.assertRaises(TypeError, f, 10) |
| 291 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 292 | class TestErrorHandlingPython(TestErrorHandling, unittest.TestCase): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 293 | module = py_bisect |
| 294 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 295 | class TestErrorHandlingC(TestErrorHandling, unittest.TestCase): |
Christian Heimes | d3eb5a15 | 2008-02-24 00:38:49 +0000 | [diff] [blame] | 296 | module = c_bisect |
| 297 | |
Raymond Hettinger | 6325178 | 2004-09-27 22:48:40 +0000 | [diff] [blame] | 298 | #============================================================================== |
| 299 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 300 | class TestDocExample: |
| 301 | def test_grades(self): |
| 302 | def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'): |
| 303 | i = self.module.bisect(breakpoints, score) |
| 304 | return grades[i] |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 305 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 306 | result = [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]] |
| 307 | self.assertEqual(result, ['F', 'A', 'C', 'C', 'B', 'A', 'A']) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 308 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 309 | def test_colors(self): |
| 310 | data = [('red', 5), ('blue', 1), ('yellow', 8), ('black', 0)] |
| 311 | data.sort(key=lambda r: r[1]) |
| 312 | keys = [r[1] for r in data] |
| 313 | bisect_left = self.module.bisect_left |
| 314 | self.assertEqual(data[bisect_left(keys, 0)], ('black', 0)) |
| 315 | self.assertEqual(data[bisect_left(keys, 1)], ('blue', 1)) |
| 316 | self.assertEqual(data[bisect_left(keys, 5)], ('red', 5)) |
| 317 | self.assertEqual(data[bisect_left(keys, 8)], ('yellow', 8)) |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 318 | |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 319 | class TestDocExamplePython(TestDocExample, unittest.TestCase): |
| 320 | module = py_bisect |
| 321 | |
| 322 | class TestDocExampleC(TestDocExample, unittest.TestCase): |
| 323 | module = c_bisect |
Raymond Hettinger | 4422375 | 2003-01-16 12:31:36 +0000 | [diff] [blame] | 324 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 325 | #------------------------------------------------------------------------------ |
| 326 | |
Raymond Hettinger | d230550 | 2003-01-16 12:02:35 +0000 | [diff] [blame] | 327 | if __name__ == "__main__": |
Ezio Melotti | f472a90 | 2013-01-10 04:32:01 +0200 | [diff] [blame] | 328 | unittest.main() |