mirror of
https://github.com/python/cpython.git
synced 2025-07-30 06:34:15 +00:00
8a87f5d37e
I modified this patch some by fixing style, some error checking, and adding XXX comments. This patch requires review and some changes are to be expected. I'm checking in now to get the greatest possible review and establish a baseline for moving forward. I don't want this to hold up release if possible.
215 lines
6.5 KiB
Python
215 lines
6.5 KiB
Python
import unittest
|
|
from test import test_support
|
|
import operator
|
|
from sys import maxint
|
|
|
|
class oldstyle:
|
|
def __index__(self):
|
|
return self.ind
|
|
|
|
class newstyle(object):
|
|
def __index__(self):
|
|
return self.ind
|
|
|
|
class TrapInt(int):
|
|
def __index__(self):
|
|
return self
|
|
|
|
class TrapLong(long):
|
|
def __index__(self):
|
|
return self
|
|
|
|
class BaseTestCase(unittest.TestCase):
|
|
def setUp(self):
|
|
self.o = oldstyle()
|
|
self.n = newstyle()
|
|
|
|
def test_basic(self):
|
|
self.o.ind = -2
|
|
self.n.ind = 2
|
|
self.assertEqual(operator.index(self.o), -2)
|
|
self.assertEqual(operator.index(self.n), 2)
|
|
|
|
def test_slice(self):
|
|
self.o.ind = 1
|
|
self.n.ind = 2
|
|
slc = slice(self.o, self.o, self.o)
|
|
check_slc = slice(1, 1, 1)
|
|
self.assertEqual(slc.indices(self.o), check_slc.indices(1))
|
|
slc = slice(self.n, self.n, self.n)
|
|
check_slc = slice(2, 2, 2)
|
|
self.assertEqual(slc.indices(self.n), check_slc.indices(2))
|
|
|
|
def test_wrappers(self):
|
|
self.o.ind = 4
|
|
self.n.ind = 5
|
|
self.assertEqual(6 .__index__(), 6)
|
|
self.assertEqual(-7L.__index__(), -7)
|
|
self.assertEqual(self.o.__index__(), 4)
|
|
self.assertEqual(self.n.__index__(), 5)
|
|
|
|
def test_infinite_recursion(self):
|
|
self.failUnlessRaises(TypeError, operator.index, TrapInt())
|
|
self.failUnlessRaises(TypeError, operator.index, TrapLong())
|
|
self.failUnless(slice(TrapInt()).indices(0)==(0,0,1))
|
|
self.failUnlessRaises(TypeError, slice(TrapLong()).indices, 0)
|
|
|
|
def test_error(self):
|
|
self.o.ind = 'dumb'
|
|
self.n.ind = 'bad'
|
|
self.failUnlessRaises(TypeError, operator.index, self.o)
|
|
self.failUnlessRaises(TypeError, operator.index, self.n)
|
|
self.failUnlessRaises(TypeError, slice(self.o).indices, 0)
|
|
self.failUnlessRaises(TypeError, slice(self.n).indices, 0)
|
|
|
|
|
|
class SeqTestCase(unittest.TestCase):
|
|
# This test case isn't run directly. It just defines common tests
|
|
# to the different sequence types below
|
|
def setUp(self):
|
|
self.o = oldstyle()
|
|
self.n = newstyle()
|
|
self.o2 = oldstyle()
|
|
self.n2 = newstyle()
|
|
|
|
def test_index(self):
|
|
self.o.ind = -2
|
|
self.n.ind = 2
|
|
self.assertEqual(self.seq[self.n], self.seq[2])
|
|
self.assertEqual(self.seq[self.o], self.seq[-2])
|
|
|
|
def test_slice(self):
|
|
self.o.ind = 1
|
|
self.o2.ind = 3
|
|
self.n.ind = 2
|
|
self.n2.ind = 4
|
|
self.assertEqual(self.seq[self.o:self.o2], self.seq[1:3])
|
|
self.assertEqual(self.seq[self.n:self.n2], self.seq[2:4])
|
|
|
|
def test_repeat(self):
|
|
self.o.ind = 3
|
|
self.n.ind = 2
|
|
self.assertEqual(self.seq * self.o, self.seq * 3)
|
|
self.assertEqual(self.seq * self.n, self.seq * 2)
|
|
self.assertEqual(self.o * self.seq, self.seq * 3)
|
|
self.assertEqual(self.n * self.seq, self.seq * 2)
|
|
|
|
def test_wrappers(self):
|
|
self.o.ind = 4
|
|
self.n.ind = 5
|
|
self.assertEqual(self.seq.__getitem__(self.o), self.seq[4])
|
|
self.assertEqual(self.seq.__mul__(self.o), self.seq * 4)
|
|
self.assertEqual(self.seq.__rmul__(self.o), self.seq * 4)
|
|
self.assertEqual(self.seq.__getitem__(self.n), self.seq[5])
|
|
self.assertEqual(self.seq.__mul__(self.n), self.seq * 5)
|
|
self.assertEqual(self.seq.__rmul__(self.n), self.seq * 5)
|
|
|
|
def test_infinite_recursion(self):
|
|
self.failUnlessRaises(TypeError, operator.getitem, self.seq, TrapInt())
|
|
self.failUnlessRaises(TypeError, operator.getitem, self.seq, TrapLong())
|
|
|
|
def test_error(self):
|
|
self.o.ind = 'dumb'
|
|
self.n.ind = 'bad'
|
|
indexobj = lambda x, obj: obj.seq[x]
|
|
self.failUnlessRaises(TypeError, indexobj, self.o, self)
|
|
self.failUnlessRaises(TypeError, indexobj, self.n, self)
|
|
sliceobj = lambda x, obj: obj.seq[x:]
|
|
self.failUnlessRaises(TypeError, sliceobj, self.o, self)
|
|
self.failUnlessRaises(TypeError, sliceobj, self.n, self)
|
|
|
|
|
|
class ListTestCase(SeqTestCase):
|
|
seq = [0,10,20,30,40,50]
|
|
|
|
def test_setdelitem(self):
|
|
self.o.ind = -2
|
|
self.n.ind = 2
|
|
lst = list('ab!cdefghi!j')
|
|
del lst[self.o]
|
|
del lst[self.n]
|
|
lst[self.o] = 'X'
|
|
lst[self.n] = 'Y'
|
|
self.assertEqual(lst, list('abYdefghXj'))
|
|
|
|
lst = [5, 6, 7, 8, 9, 10, 11]
|
|
lst.__setitem__(self.n, "here")
|
|
self.assertEqual(lst, [5, 6, "here", 8, 9, 10, 11])
|
|
lst.__delitem__(self.n)
|
|
self.assertEqual(lst, [5, 6, 8, 9, 10, 11])
|
|
|
|
def test_inplace_repeat(self):
|
|
self.o.ind = 2
|
|
self.n.ind = 3
|
|
lst = [6, 4]
|
|
lst *= self.o
|
|
self.assertEqual(lst, [6, 4, 6, 4])
|
|
lst *= self.n
|
|
self.assertEqual(lst, [6, 4, 6, 4] * 3)
|
|
|
|
lst = [5, 6, 7, 8, 9, 11]
|
|
l2 = lst.__imul__(self.n)
|
|
self.assert_(l2 is lst)
|
|
self.assertEqual(lst, [5, 6, 7, 8, 9, 11] * 3)
|
|
|
|
|
|
class TupleTestCase(SeqTestCase):
|
|
seq = (0,10,20,30,40,50)
|
|
|
|
class StringTestCase(SeqTestCase):
|
|
seq = "this is a test"
|
|
|
|
class UnicodeTestCase(SeqTestCase):
|
|
seq = u"this is a test"
|
|
|
|
|
|
class XRangeTestCase(unittest.TestCase):
|
|
|
|
def test_xrange(self):
|
|
n = newstyle()
|
|
n.ind = 5
|
|
self.assertEqual(xrange(1, 20)[n], 6)
|
|
self.assertEqual(xrange(1, 20).__getitem__(n), 6)
|
|
|
|
class OverflowTestCase(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
self.pos = 2**100
|
|
self.neg = -self.pos
|
|
|
|
def test_large_longs(self):
|
|
self.assertEqual(self.pos.__index__(), self.pos)
|
|
self.assertEqual(self.neg.__index__(), self.neg)
|
|
|
|
def test_getitem(self):
|
|
class GetItem(object):
|
|
def __len__(self):
|
|
return maxint
|
|
def __getitem__(self, key):
|
|
return key
|
|
def __getslice__(self, i, j):
|
|
return i, j
|
|
x = GetItem()
|
|
self.assertEqual(x[self.pos], self.pos)
|
|
self.assertEqual(x[self.neg], self.neg)
|
|
self.assertEqual(x[self.neg:self.pos], (-1, maxint))
|
|
self.assertEqual(x[self.neg:self.pos:1].indices(maxint), (0, maxint, 1))
|
|
|
|
def test_sequence_repeat(self):
|
|
self.failUnlessRaises(OverflowError, lambda: "a" * self.pos)
|
|
self.failUnlessRaises(OverflowError, lambda: "a" * self.neg)
|
|
|
|
|
|
def test_main():
|
|
test_support.run_unittest(
|
|
BaseTestCase,
|
|
ListTestCase,
|
|
TupleTestCase,
|
|
StringTestCase,
|
|
UnicodeTestCase,
|
|
XRangeTestCase,
|
|
OverflowTestCase,
|
|
)
|
|
|
|
if __name__ == "__main__":
|
|
test_main()
|