1berry/cpython
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Convert to unittest format so that more tests can be added cleanly.

Browse Source
This commit is contained in:
Raymond Hettinger 2003-01-16 12:02:35 +00:00
parent 13dd9d9978
commit d230550a6b
1 changed files with 129 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

249
Lib/test/test_bisect.py
View File

@ -1,127 +1,136 @@
from test.test_support import TestFailed import unittest
from test import test_support
import bisect from bisect import bisect_right, bisect_left, insort_left, insort_right
import sys
nerrors = 0
def check_bisect(func, list, elt, expected):
global nerrors
got = func(list, elt)
if got != expected:
print >> sys.stderr, \
"expected %s(%s, %s) -> %s, but got %s" % (func.__name__,
list,
elt,
expected,
got)
nerrors += 1
# XXX optional slice arguments need tests. # XXX optional slice arguments need tests.
check_bisect(bisect.bisect_right, [], 1, 0)
check_bisect(bisect.bisect_right, [1], 0, 0)
check_bisect(bisect.bisect_right, [1], 1, 1)
check_bisect(bisect.bisect_right, [1], 2, 1)
check_bisect(bisect.bisect_right, [1, 1], 0, 0)
check_bisect(bisect.bisect_right, [1, 1], 1, 2)
check_bisect(bisect.bisect_right, [1, 1], 2, 2)
check_bisect(bisect.bisect_right, [1, 1, 1], 0, 0)
check_bisect(bisect.bisect_right, [1, 1, 1], 1, 3)
check_bisect(bisect.bisect_right, [1, 1, 1], 2, 3)
check_bisect(bisect.bisect_right, [1, 1, 1, 1], 0, 0)
check_bisect(bisect.bisect_right, [1, 1, 1, 1], 1, 4)
check_bisect(bisect.bisect_right, [1, 1, 1, 1], 2, 4)
check_bisect(bisect.bisect_right, [1, 2], 0, 0)
check_bisect(bisect.bisect_right, [1, 2], 1, 1)
check_bisect(bisect.bisect_right, [1, 2], 1.5, 1)
check_bisect(bisect.bisect_right, [1, 2], 2, 2)
check_bisect(bisect.bisect_right, [1, 2], 3, 2)
check_bisect(bisect.bisect_right, [1, 1, 2, 2], 0, 0)
check_bisect(bisect.bisect_right, [1, 1, 2, 2], 1, 2)
check_bisect(bisect.bisect_right, [1, 1, 2, 2], 1.5, 2)
check_bisect(bisect.bisect_right, [1, 1, 2, 2], 2, 4)
check_bisect(bisect.bisect_right, [1, 1, 2, 2], 3, 4)
check_bisect(bisect.bisect_right, [1, 2, 3], 0, 0)
check_bisect(bisect.bisect_right, [1, 2, 3], 1, 1)
check_bisect(bisect.bisect_right, [1, 2, 3], 1.5, 1)
check_bisect(bisect.bisect_right, [1, 2, 3], 2, 2)
check_bisect(bisect.bisect_right, [1, 2, 3], 2.5, 2)
check_bisect(bisect.bisect_right, [1, 2, 3], 3, 3)
check_bisect(bisect.bisect_right, [1, 2, 3], 4, 3)
check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0)
check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 1)
check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1)
check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 3)
check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3)
check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 6)
check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6)
check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 10)
check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10)
check_bisect(bisect.bisect_left, [], 1, 0) class TestBisect(unittest.TestCase):
check_bisect(bisect.bisect_left, [1], 0, 0)
check_bisect(bisect.bisect_left, [1], 1, 0)
check_bisect(bisect.bisect_left, [1], 2, 1)
check_bisect(bisect.bisect_left, [1, 1], 0, 0)
check_bisect(bisect.bisect_left, [1, 1], 1, 0)
check_bisect(bisect.bisect_left, [1, 1], 2, 2)
check_bisect(bisect.bisect_left, [1, 1, 1], 0, 0)
check_bisect(bisect.bisect_left, [1, 1, 1], 1, 0)
check_bisect(bisect.bisect_left, [1, 1, 1], 2, 3)
check_bisect(bisect.bisect_left, [1, 1, 1, 1], 0, 0)
check_bisect(bisect.bisect_left, [1, 1, 1, 1], 1, 0)
check_bisect(bisect.bisect_left, [1, 1, 1, 1], 2, 4)
check_bisect(bisect.bisect_left, [1, 2], 0, 0)
check_bisect(bisect.bisect_left, [1, 2], 1, 0)
check_bisect(bisect.bisect_left, [1, 2], 1.5, 1)
check_bisect(bisect.bisect_left, [1, 2], 2, 1)
check_bisect(bisect.bisect_left, [1, 2], 3, 2)
check_bisect(bisect.bisect_left, [1, 1, 2, 2], 0, 0)
check_bisect(bisect.bisect_left, [1, 1, 2, 2], 1, 0)
check_bisect(bisect.bisect_left, [1, 1, 2, 2], 1.5, 2)
check_bisect(bisect.bisect_left, [1, 1, 2, 2], 2, 2)
check_bisect(bisect.bisect_left, [1, 1, 2, 2], 3, 4)
check_bisect(bisect.bisect_left, [1, 2, 3], 0, 0)
check_bisect(bisect.bisect_left, [1, 2, 3], 1, 0)
check_bisect(bisect.bisect_left, [1, 2, 3], 1.5, 1)
check_bisect(bisect.bisect_left, [1, 2, 3], 2, 1)
check_bisect(bisect.bisect_left, [1, 2, 3], 2.5, 2)
check_bisect(bisect.bisect_left, [1, 2, 3], 3, 2)
check_bisect(bisect.bisect_left, [1, 2, 3], 4, 3)
check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0)
check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 0)
check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1)
check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 1)
check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3)
check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 3)
check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6)
check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 6)
check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10)
def check_insort(n): precomputedCases = [
global nerrors (bisect_right, [], 1, 0),
from random import choice (bisect_right, [1], 0, 0),
import sys (bisect_right, [1], 1, 1),
digits = "0123456789" (bisect_right, [1], 2, 1),
raw = [] (bisect_right, [1, 1], 0, 0),
insorted = [] (bisect_right, [1, 1], 1, 2),
for i in range(n): (bisect_right, [1, 1], 2, 2),
digit = choice(digits) (bisect_right, [1, 1, 1], 0, 0),
raw.append(digit) (bisect_right, [1, 1, 1], 1, 3),
if digit in "02468": (bisect_right, [1, 1, 1], 2, 3),
f = bisect.insort_left (bisect_right, [1, 1, 1, 1], 0, 0),
else: (bisect_right, [1, 1, 1, 1], 1, 4),
f = bisect.insort_right (bisect_right, [1, 1, 1, 1], 2, 4),
f(insorted, digit) (bisect_right, [1, 2], 0, 0),
sorted = raw[:] (bisect_right, [1, 2], 1, 1),
sorted.sort() (bisect_right, [1, 2], 1.5, 1),
if sorted == insorted: (bisect_right, [1, 2], 2, 2),
return (bisect_right, [1, 2], 3, 2),
print >> sys.stderr, "insort test failed: raw %s got %s" % (raw, insorted) (bisect_right, [1, 1, 2, 2], 0, 0),
nerrors += 1 (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),
check_insort(500) (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)
]
def test_precomputed(self):
for func, list, elt, expected in self.precomputedCases:
self.assertEqual(func(list, elt), expected)
#==============================================================================
class TestInsort(unittest.TestCase):
def test_vsListSort(self, n=500):
from random import choice
digits = "0123456789"
raw = []
insorted = []
for i in range(n):
digit = choice(digits)
raw.append(digit)
if digit in "02468":
f = insort_left
else:
f = insort_right
f(insorted, digit)
sorted = raw[:]
sorted.sort()
self.assertEqual(sorted, insorted)
#==============================================================================
def makeAllTests():
suite = unittest.TestSuite()
for klass in (TestBisect,
TestInsort
):
suite.addTest(unittest.makeSuite(klass))
return suite
#------------------------------------------------------------------------------
def test_main(verbose=None):
from test import test_bisect
suite = makeAllTests()
test_support.run_suite(suite)
if __name__ == "__main__":
test_main(verbose=True)
if nerrors:
raise TestFailed("%d errors in test_bisect" % nerrors)