mirror of
https://github.com/python/cpython.git
synced 2025-08-01 23:53:15 +00:00
In test_heapq and test_bisect, test both the Python and the C implementation.
Originally written for GHOP by Josip Dzolonga, heavily patched by me.
This commit is contained in:
Georg Brandl
parent
c76ea27965
commit
0bb8567e1e
2 changed files with 232 additions and 157 deletions
|
|
@ -1,91 +1,113 @@
|
|||
import sys
|
||||
import unittest
|
||||
from test import test_support
|
||||
from bisect import bisect_right, bisect_left, insort_left, insort_right, insort, bisect
|
||||
from UserList import UserList
|
||||
|
||||
# We do a bit of trickery here to be able to test both the C implementation
|
||||
# and the Python implementation of the module.
|
||||
|
||||
# Make it impossible to import the C implementation anymore.
|
||||
sys.modules['_bisect'] = 0
|
||||
# We must also handle the case that bisect was imported before.
|
||||
if 'bisect' in sys.modules:
|
||||
del sys.modules['bisect']
|
||||
|
||||
# Now we can import the module and get the pure Python implementation.
|
||||
import bisect as py_bisect
|
||||
|
||||
# Restore everything to normal.
|
||||
del sys.modules['_bisect']
|
||||
del sys.modules['bisect']
|
||||
|
||||
# This is now the module with the C implementation.
|
||||
import bisect as c_bisect
|
||||
|
||||
|
||||
class TestBisect(unittest.TestCase):
|
||||
module = None
|
||||
|
||||
precomputedCases = [
|
||||
(bisect_right, [], 1, 0),
|
||||
(bisect_right, [1], 0, 0),
|
||||
(bisect_right, [1], 1, 1),
|
||||
(bisect_right, [1], 2, 1),
|
||||
(bisect_right, [1, 1], 0, 0),
|
||||
(bisect_right, [1, 1], 1, 2),
|
||||
(bisect_right, [1, 1], 2, 2),
|
||||
(bisect_right, [1, 1, 1], 0, 0),
|
||||
(bisect_right, [1, 1, 1], 1, 3),
|
||||
(bisect_right, [1, 1, 1], 2, 3),
|
||||
(bisect_right, [1, 1, 1, 1], 0, 0),
|
||||
(bisect_right, [1, 1, 1, 1], 1, 4),
|
||||
(bisect_right, [1, 1, 1, 1], 2, 4),
|
||||
(bisect_right, [1, 2], 0, 0),
|
||||
(bisect_right, [1, 2], 1, 1),
|
||||
(bisect_right, [1, 2], 1.5, 1),
|
||||
(bisect_right, [1, 2], 2, 2),
|
||||
(bisect_right, [1, 2], 3, 2),
|
||||
(bisect_right, [1, 1, 2, 2], 0, 0),
|
||||
(bisect_right, [1, 1, 2, 2], 1, 2),
|
||||
(bisect_right, [1, 1, 2, 2], 1.5, 2),
|
||||
(bisect_right, [1, 1, 2, 2], 2, 4),
|
||||
(bisect_right, [1, 1, 2, 2], 3, 4),
|
||||
(bisect_right, [1, 2, 3], 0, 0),
|
||||
(bisect_right, [1, 2, 3], 1, 1),
|
||||
(bisect_right, [1, 2, 3], 1.5, 1),
|
||||
(bisect_right, [1, 2, 3], 2, 2),
|
||||
(bisect_right, [1, 2, 3], 2.5, 2),
|
||||
(bisect_right, [1, 2, 3], 3, 3),
|
||||
(bisect_right, [1, 2, 3], 4, 3),
|
||||
(bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0),
|
||||
(bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 1),
|
||||
(bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1),
|
||||
(bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 3),
|
||||
(bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3),
|
||||
(bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 6),
|
||||
(bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6),
|
||||
(bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 10),
|
||||
(bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10),
|
||||
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),
|
||||
|
||||
(bisect_left, [], 1, 0),
|
||||
(bisect_left, [1], 0, 0),
|
||||
(bisect_left, [1], 1, 0),
|
||||
(bisect_left, [1], 2, 1),
|
||||
(bisect_left, [1, 1], 0, 0),
|
||||
(bisect_left, [1, 1], 1, 0),
|
||||
(bisect_left, [1, 1], 2, 2),
|
||||
(bisect_left, [1, 1, 1], 0, 0),
|
||||
(bisect_left, [1, 1, 1], 1, 0),
|
||||
(bisect_left, [1, 1, 1], 2, 3),
|
||||
(bisect_left, [1, 1, 1, 1], 0, 0),
|
||||
(bisect_left, [1, 1, 1, 1], 1, 0),
|
||||
(bisect_left, [1, 1, 1, 1], 2, 4),
|
||||
(bisect_left, [1, 2], 0, 0),
|
||||
(bisect_left, [1, 2], 1, 0),
|
||||
(bisect_left, [1, 2], 1.5, 1),
|
||||
(bisect_left, [1, 2], 2, 1),
|
||||
(bisect_left, [1, 2], 3, 2),
|
||||
(bisect_left, [1, 1, 2, 2], 0, 0),
|
||||
(bisect_left, [1, 1, 2, 2], 1, 0),
|
||||
(bisect_left, [1, 1, 2, 2], 1.5, 2),
|
||||
(bisect_left, [1, 1, 2, 2], 2, 2),
|
||||
(bisect_left, [1, 1, 2, 2], 3, 4),
|
||||
(bisect_left, [1, 2, 3], 0, 0),
|
||||
(bisect_left, [1, 2, 3], 1, 0),
|
||||
(bisect_left, [1, 2, 3], 1.5, 1),
|
||||
(bisect_left, [1, 2, 3], 2, 1),
|
||||
(bisect_left, [1, 2, 3], 2.5, 2),
|
||||
(bisect_left, [1, 2, 3], 3, 2),
|
||||
(bisect_left, [1, 2, 3], 4, 3),
|
||||
(bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0),
|
||||
(bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 0),
|
||||
(bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1),
|
||||
(bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 1),
|
||||
(bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3),
|
||||
(bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 3),
|
||||
(bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6),
|
||||
(bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 6),
|
||||
(bisect_left, [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:
|
||||
|
|
@ -98,12 +120,12 @@ class TestBisect(unittest.TestCase):
|
|||
data = [randrange(0, n, 2) for j in xrange(i)]
|
||||
data.sort()
|
||||
elem = randrange(-1, n+1)
|
||||
ip = bisect_left(data, elem)
|
||||
ip = self.module.bisect_left(data, elem)
|
||||
if ip < len(data):
|
||||
self.failUnless(elem <= data[ip])
|
||||
if ip > 0:
|
||||
self.failUnless(data[ip-1] < elem)
|
||||
ip = bisect_right(data, elem)
|
||||
ip = self.module.bisect_right(data, elem)
|
||||
if ip < len(data):
|
||||
self.failUnless(elem < data[ip])
|
||||
if ip > 0:
|
||||
|
|
@ -117,32 +139,39 @@ class TestBisect(unittest.TestCase):
|
|||
hi = min(len(data), hi)
|
||||
ip = func(data, elem, lo, hi)
|
||||
self.failUnless(lo <= ip <= hi)
|
||||
if func is bisect_left and ip < hi:
|
||||
if func is self.module.bisect_left and ip < hi:
|
||||
self.failUnless(elem <= data[ip])
|
||||
if func is bisect_left and ip > lo:
|
||||
if func is self.module.bisect_left and ip > lo:
|
||||
self.failUnless(data[ip-1] < elem)
|
||||
if func is bisect_right and ip < hi:
|
||||
if func is self.module.bisect_right and ip < hi:
|
||||
self.failUnless(elem < data[ip])
|
||||
if func is bisect_right and ip > lo:
|
||||
if func is self.module.bisect_right and ip > lo:
|
||||
self.failUnless(data[ip-1] <= elem)
|
||||
self.assertEqual(ip, max(lo, min(hi, expected)))
|
||||
|
||||
def test_backcompatibility(self):
|
||||
self.assertEqual(bisect, bisect_right)
|
||||
self.assertEqual(self.module.bisect, self.module.bisect_right)
|
||||
|
||||
def test_keyword_args(self):
|
||||
data = [10, 20, 30, 40, 50]
|
||||
self.assertEqual(bisect_left(a=data, x=25, lo=1, hi=3), 2)
|
||||
self.assertEqual(bisect_right(a=data, x=25, lo=1, hi=3), 2)
|
||||
self.assertEqual(bisect(a=data, x=25, lo=1, hi=3), 2)
|
||||
insort_left(a=data, x=25, lo=1, hi=3)
|
||||
insort_right(a=data, x=25, lo=1, hi=3)
|
||||
insort(a=data, x=25, lo=1, hi=3)
|
||||
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])
|
||||
|
||||
class TestBisectPython(TestBisect):
|
||||
module = py_bisect
|
||||
|
||||
class TestBisectC(TestBisect):
|
||||
module = c_bisect
|
||||
|
||||
#==============================================================================
|
||||
|
||||
class TestInsort(unittest.TestCase):
|
||||
module = None
|
||||
|
||||
def test_vsBuiltinSort(self, n=500):
|
||||
from random import choice
|
||||
|
|
@ -150,14 +179,20 @@ class TestInsort(unittest.TestCase):
|
|||
for i in xrange(n):
|
||||
digit = choice("0123456789")
|
||||
if digit in "02468":
|
||||
f = insort_left
|
||||
f = self.module.insort_left
|
||||
else:
|
||||
f = insort_right
|
||||
f = self.module.insort_right
|
||||
f(insorted, digit)
|
||||
self.assertEqual(sorted(insorted), insorted)
|
||||
|
||||
def test_backcompatibility(self):
|
||||
self.assertEqual(insort, insort_right)
|
||||
self.assertEqual(self.module.insort, self.module.insort_right)
|
||||
|
||||
class TestInsortPython(TestInsort):
|
||||
module = py_bisect
|
||||
|
||||
class TestInsortC(TestInsort):
|
||||
module = c_bisect
|
||||
|
||||
#==============================================================================
|
||||
|
||||
|
|
@ -178,32 +213,44 @@ class CmpErr:
|
|||
raise ZeroDivisionError
|
||||
|
||||
class TestErrorHandling(unittest.TestCase):
|
||||
module = None
|
||||
|
||||
def test_non_sequence(self):
|
||||
for f in (bisect_left, bisect_right, insort_left, insort_right):
|
||||
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 (bisect_left, bisect_right, insort_left, insort_right):
|
||||
for f in (self.module.bisect_left, self.module.bisect_right,
|
||||
self.module.insort_left, self.module.insort_right):
|
||||
self.assertRaises(AttributeError, f, LenOnly(), 10)
|
||||
|
||||
def test_get_only(self):
|
||||
for f in (bisect_left, bisect_right, insort_left, insort_right):
|
||||
for f in (self.module.bisect_left, self.module.bisect_right,
|
||||
self.module.insort_left, self.module.insort_right):
|
||||
self.assertRaises(AttributeError, f, GetOnly(), 10)
|
||||
|
||||
def test_cmp_err(self):
|
||||
seq = [CmpErr(), CmpErr(), CmpErr()]
|
||||
for f in (bisect_left, bisect_right, insort_left, insort_right):
|
||||
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 (bisect_left, bisect_right, insort_left, insort_right):
|
||||
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):
|
||||
module = py_bisect
|
||||
|
||||
class TestErrorHandlingC(TestErrorHandling):
|
||||
module = c_bisect
|
||||
|
||||
#==============================================================================
|
||||
|
||||
libreftest = """
|
||||
Example from the Library Reference: Doc/lib/libbisect.tex
|
||||
Example from the Library Reference: Doc/library/bisect.rst
|
||||
|
||||
The bisect() function is generally useful for categorizing numeric data.
|
||||
This example uses bisect() to look up a letter grade for an exam total
|
||||
|
|
@ -229,12 +276,10 @@ __test__ = {'libreftest' : libreftest}
|
|||
|
||||
def test_main(verbose=None):
|
||||
from test import test_bisect
|
||||
from types import BuiltinFunctionType
|
||||
import sys
|
||||
|
||||
test_classes = [TestBisect, TestInsort]
|
||||
if isinstance(bisect_left, BuiltinFunctionType):
|
||||
test_classes.append(TestErrorHandling)
|
||||
test_classes = [TestBisectPython, TestBisectC,
|
||||
TestInsortPython, TestInsortC,
|
||||
TestErrorHandlingPython, TestErrorHandlingC]
|
||||
|
||||
test_support.run_unittest(*test_classes)
|
||||
test_support.run_doctest(test_bisect, verbose)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue