← Back to branch summary

~ubuntu-branches/ubuntu/maverick/python3.1/maverick

« back to all changes in this revision

Viewing changes to Lib/test/test_index.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-03-23 00:01:27 UTC
  • Revision ID: james.westby@ubuntu.com-20090323000127-5fstfxju4ufrhthq
Tags: upstream-3.1~a1+20090322
Import upstream version 3.1~a1+20090322

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/test/test_index.py
 
1
import unittest
 
2
from test import support
 
3
import operator
 
4
maxsize = support.MAX_Py_ssize_t
 
5
minsize = -maxsize-1
 
6
 
 
7
class oldstyle:
 
8
    def __index__(self):
 
9
        return self.ind
 
10
 
 
11
class newstyle(object):
 
12
    def __index__(self):
 
13
        return self.ind
 
14
 
 
15
class TrapInt(int):
 
16
    def __index__(self):
 
17
        return self
 
18
 
 
19
class TrapLong(int):
 
20
    def __index__(self):
 
21
        return self
 
22
 
 
23
class BaseTestCase(unittest.TestCase):
 
24
    def setUp(self):
 
25
        self.o = oldstyle()
 
26
        self.n = newstyle()
 
27
 
 
28
    def test_basic(self):
 
29
        self.o.ind = -2
 
30
        self.n.ind = 2
 
31
        self.assertEqual(operator.index(self.o), -2)
 
32
        self.assertEqual(operator.index(self.n), 2)
 
33
 
 
34
    def test_slice(self):
 
35
        self.o.ind = 1
 
36
        self.n.ind = 2
 
37
        slc = slice(self.o, self.o, self.o)
 
38
        check_slc = slice(1, 1, 1)
 
39
        self.assertEqual(slc.indices(self.o), check_slc.indices(1))
 
40
        slc = slice(self.n, self.n, self.n)
 
41
        check_slc = slice(2, 2, 2)
 
42
        self.assertEqual(slc.indices(self.n), check_slc.indices(2))
 
43
 
 
44
    def test_wrappers(self):
 
45
        self.o.ind = 4
 
46
        self.n.ind = 5
 
47
        self.assertEqual(6 .__index__(), 6)
 
48
        self.assertEqual(-7 .__index__(), -7)
 
49
        self.assertEqual(self.o.__index__(), 4)
 
50
        self.assertEqual(self.n.__index__(), 5)
 
51
 
 
52
    def test_subclasses(self):
 
53
        r = list(range(10))
 
54
        self.assertEqual(r[TrapInt(5):TrapInt(10)], r[5:10])
 
55
        self.assertEqual(r[TrapLong(5):TrapLong(10)], r[5:10])
 
56
        self.assertEqual(slice(TrapInt()).indices(0), (0,0,1))
 
57
        self.assertEqual(slice(TrapLong(0)).indices(0), (0,0,1))
 
58
 
 
59
    def test_error(self):
 
60
        self.o.ind = 'dumb'
 
61
        self.n.ind = 'bad'
 
62
        self.failUnlessRaises(TypeError, operator.index, self.o)
 
63
        self.failUnlessRaises(TypeError, operator.index, self.n)
 
64
        self.failUnlessRaises(TypeError, slice(self.o).indices, 0)
 
65
        self.failUnlessRaises(TypeError, slice(self.n).indices, 0)
 
66
 
 
67
 
 
68
class SeqTestCase(unittest.TestCase):
 
69
    # This test case isn't run directly. It just defines common tests
 
70
    # to the different sequence types below
 
71
    def setUp(self):
 
72
        self.o = oldstyle()
 
73
        self.n = newstyle()
 
74
        self.o2 = oldstyle()
 
75
        self.n2 = newstyle()
 
76
 
 
77
    def test_index(self):
 
78
        self.o.ind = -2
 
79
        self.n.ind = 2
 
80
        self.assertEqual(self.seq[self.n], self.seq[2])
 
81
        self.assertEqual(self.seq[self.o], self.seq[-2])
 
82
 
 
83
    def test_slice(self):
 
84
        self.o.ind = 1
 
85
        self.o2.ind = 3
 
86
        self.n.ind = 2
 
87
        self.n2.ind = 4
 
88
        self.assertEqual(self.seq[self.o:self.o2], self.seq[1:3])
 
89
        self.assertEqual(self.seq[self.n:self.n2], self.seq[2:4])
 
90
 
 
91
    def test_repeat(self):
 
92
        self.o.ind = 3
 
93
        self.n.ind = 2
 
94
        self.assertEqual(self.seq * self.o, self.seq * 3)
 
95
        self.assertEqual(self.seq * self.n, self.seq * 2)
 
96
        self.assertEqual(self.o * self.seq, self.seq * 3)
 
97
        self.assertEqual(self.n * self.seq, self.seq * 2)
 
98
 
 
99
    def test_wrappers(self):
 
100
        self.o.ind = 4
 
101
        self.n.ind = 5
 
102
        self.assertEqual(self.seq.__getitem__(self.o), self.seq[4])
 
103
        self.assertEqual(self.seq.__mul__(self.o), self.seq * 4)
 
104
        self.assertEqual(self.seq.__rmul__(self.o), self.seq * 4)
 
105
        self.assertEqual(self.seq.__getitem__(self.n), self.seq[5])
 
106
        self.assertEqual(self.seq.__mul__(self.n), self.seq * 5)
 
107
        self.assertEqual(self.seq.__rmul__(self.n), self.seq * 5)
 
108
 
 
109
    def test_subclasses(self):
 
110
        self.assertEqual(self.seq[TrapInt()], self.seq[0])
 
111
        self.assertEqual(self.seq[TrapLong()], self.seq[0])
 
112
 
 
113
    def test_error(self):
 
114
        self.o.ind = 'dumb'
 
115
        self.n.ind = 'bad'
 
116
        indexobj = lambda x, obj: obj.seq[x]
 
117
        self.failUnlessRaises(TypeError, indexobj, self.o, self)
 
118
        self.failUnlessRaises(TypeError, indexobj, self.n, self)
 
119
        sliceobj = lambda x, obj: obj.seq[x:]
 
120
        self.failUnlessRaises(TypeError, sliceobj, self.o, self)
 
121
        self.failUnlessRaises(TypeError, sliceobj, self.n, self)
 
122
 
 
123
 
 
124
class ListTestCase(SeqTestCase):
 
125
    seq = [0,10,20,30,40,50]
 
126
 
 
127
    def test_setdelitem(self):
 
128
        self.o.ind = -2
 
129
        self.n.ind = 2
 
130
        lst = list('ab!cdefghi!j')
 
131
        del lst[self.o]
 
132
        del lst[self.n]
 
133
        lst[self.o] = 'X'
 
134
        lst[self.n] = 'Y'
 
135
        self.assertEqual(lst, list('abYdefghXj'))
 
136
 
 
137
        lst = [5, 6, 7, 8, 9, 10, 11]
 
138
        lst.__setitem__(self.n, "here")
 
139
        self.assertEqual(lst, [5, 6, "here", 8, 9, 10, 11])
 
140
        lst.__delitem__(self.n)
 
141
        self.assertEqual(lst, [5, 6, 8, 9, 10, 11])
 
142
 
 
143
    def test_inplace_repeat(self):
 
144
        self.o.ind = 2
 
145
        self.n.ind = 3
 
146
        lst = [6, 4]
 
147
        lst *= self.o
 
148
        self.assertEqual(lst, [6, 4, 6, 4])
 
149
        lst *= self.n
 
150
        self.assertEqual(lst, [6, 4, 6, 4] * 3)
 
151
 
 
152
        lst = [5, 6, 7, 8, 9, 11]
 
153
        l2 = lst.__imul__(self.n)
 
154
        self.assert_(l2 is lst)
 
155
        self.assertEqual(lst, [5, 6, 7, 8, 9, 11] * 3)
 
156
 
 
157
 
 
158
class TupleTestCase(SeqTestCase):
 
159
    seq = (0,10,20,30,40,50)
 
160
 
 
161
class StringTestCase(SeqTestCase):
 
162
    seq = "this is a test"
 
163
 
 
164
class UnicodeTestCase(SeqTestCase):
 
165
    seq = "this is a test"
 
166
 
 
167
 
 
168
class OverflowTestCase(unittest.TestCase):
 
169
 
 
170
    def setUp(self):
 
171
        self.pos = 2**100
 
172
        self.neg = -self.pos
 
173
 
 
174
    def test_large_longs(self):
 
175
        self.assertEqual(self.pos.__index__(), self.pos)
 
176
        self.assertEqual(self.neg.__index__(), self.neg)
 
177
 
 
178
    def test_getitem(self):
 
179
        class GetItem(object):
 
180
            def __len__(self):
 
181
                return sys.maxsize
 
182
            def __getitem__(self, key):
 
183
                return key
 
184
        x = GetItem()
 
185
        self.assertEqual(x[self.pos], self.pos)
 
186
        self.assertEqual(x[self.neg], self.neg)
 
187
        self.assertEqual(x[self.neg:self.pos].indices(maxsize),
 
188
                         (0, maxsize, 1))
 
189
 
 
190
    def test_sequence_repeat(self):
 
191
        self.failUnlessRaises(OverflowError, lambda: "a" * self.pos)
 
192
        self.failUnlessRaises(OverflowError, lambda: "a" * self.neg)
 
193
 
 
194
 
 
195
def test_main():
 
196
    support.run_unittest(
 
197
        BaseTestCase,
 
198
        ListTestCase,
 
199
        TupleTestCase,
 
200
        StringTestCase,
 
201
        UnicodeTestCase,
 
202
        OverflowTestCase,
 
203
    )
 
204
 
 
205
if __name__ == "__main__":
 
206
    test_main()