← Back to branch summary

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

« back to all changes in this revision

Viewing changes to Lib/test/test_bigmem.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_bigmem.py
 
1
from test import support
 
2
from test.support import bigmemtest, _1G, _2G, _4G, precisionbigmemtest
 
3
 
 
4
import unittest
 
5
import operator
 
6
import sys
 
7
import functools
 
8
 
 
9
# Bigmem testing houserules:
 
10
#
 
11
#  - Try not to allocate too many large objects. It's okay to rely on
 
12
#    refcounting semantics, but don't forget that 's = create_largestring()'
 
13
#    doesn't release the old 's' (if it exists) until well after its new
 
14
#    value has been created. Use 'del s' before the create_largestring call.
 
15
#
 
16
#  - Do *not* compare large objects using assertEquals or similar. It's a
 
17
#    lengthy operation and the errormessage will be utterly useless due to
 
18
#    its size. To make sure whether a result has the right contents, better
 
19
#    to use the strip or count methods, or compare meaningful slices.
 
20
#
 
21
#  - Don't forget to test for large indices, offsets and results and such,
 
22
#    in addition to large sizes.
 
23
#
 
24
#  - When repeating an object (say, a substring, or a small list) to create
 
25
#    a large object, make the subobject of a length that is not a power of
 
26
#    2. That way, int-wrapping problems are more easily detected.
 
27
#
 
28
#  - While the bigmemtest decorator speaks of 'minsize', all tests will
 
29
#    actually be called with a much smaller number too, in the normal
 
30
#    test run (5Kb currently.) This is so the tests themselves get frequent
 
31
#    testing. Consequently, always make all large allocations based on the
 
32
#    passed-in 'size', and don't rely on the size being very large. Also,
 
33
#    memuse-per-size should remain sane (less than a few thousand); if your
 
34
#    test uses more, adjust 'size' upward, instead.
 
35
 
 
36
# BEWARE: it seems that one failing test can yield other subsequent tests to
 
37
# fail as well. I do not know whether it is due to memory fragmentation
 
38
# issues, or other specifics of the platform malloc() routine.
 
39
 
 
40
character_size = 4 if sys.maxunicode > 0xFFFF else 2
 
41
 
 
42
 
 
43
class BaseStrTest:
 
44
 
 
45
    @bigmemtest(minsize=_2G, memuse=2)
 
46
    def test_capitalize(self, size):
 
47
        _ = self.from_latin1
 
48
        SUBSTR = self.from_latin1(' abc def ghi')
 
49
        s = _('-') * size + SUBSTR
 
50
        caps = s.capitalize()
 
51
        self.assertEquals(caps[-len(SUBSTR):],
 
52
                         SUBSTR.capitalize())
 
53
        self.assertEquals(caps.lstrip(_('-')), SUBSTR)
 
54
 
 
55
    @bigmemtest(minsize=_2G + 10, memuse=1)
 
56
    def test_center(self, size):
 
57
        SUBSTR = self.from_latin1(' abc def ghi')
 
58
        s = SUBSTR.center(size)
 
59
        self.assertEquals(len(s), size)
 
60
        lpadsize = rpadsize = (len(s) - len(SUBSTR)) // 2
 
61
        if len(s) % 2:
 
62
            lpadsize += 1
 
63
        self.assertEquals(s[lpadsize:-rpadsize], SUBSTR)
 
64
        self.assertEquals(s.strip(), SUBSTR.strip())
 
65
 
 
66
    @bigmemtest(minsize=_2G, memuse=2)
 
67
    def test_count(self, size):
 
68
        _ = self.from_latin1
 
69
        SUBSTR = _(' abc def ghi')
 
70
        s = _('.') * size + SUBSTR
 
71
        self.assertEquals(s.count(_('.')), size)
 
72
        s += _('.')
 
73
        self.assertEquals(s.count(_('.')), size + 1)
 
74
        self.assertEquals(s.count(_(' ')), 3)
 
75
        self.assertEquals(s.count(_('i')), 1)
 
76
        self.assertEquals(s.count(_('j')), 0)
 
77
 
 
78
    @bigmemtest(minsize=_2G, memuse=2)
 
79
    def test_endswith(self, size):
 
80
        _ = self.from_latin1
 
81
        SUBSTR = _(' abc def ghi')
 
82
        s = _('-') * size + SUBSTR
 
83
        self.failUnless(s.endswith(SUBSTR))
 
84
        self.failUnless(s.endswith(s))
 
85
        s2 = _('...') + s
 
86
        self.failUnless(s2.endswith(s))
 
87
        self.failIf(s.endswith(_('a') + SUBSTR))
 
88
        self.failIf(SUBSTR.endswith(s))
 
89
 
 
90
    @bigmemtest(minsize=_2G + 10, memuse=2)
 
91
    def test_expandtabs(self, size):
 
92
        _ = self.from_latin1
 
93
        s = _('-') * size
 
94
        tabsize = 8
 
95
        self.assertEquals(s.expandtabs(), s)
 
96
        del s
 
97
        slen, remainder = divmod(size, tabsize)
 
98
        s = _('       \t') * slen
 
99
        s = s.expandtabs(tabsize)
 
100
        self.assertEquals(len(s), size - remainder)
 
101
        self.assertEquals(len(s.strip(_(' '))), 0)
 
102
 
 
103
    @bigmemtest(minsize=_2G, memuse=2)
 
104
    def test_find(self, size):
 
105
        _ = self.from_latin1
 
106
        SUBSTR = _(' abc def ghi')
 
107
        sublen = len(SUBSTR)
 
108
        s = _('').join([SUBSTR, _('-') * size, SUBSTR])
 
109
        self.assertEquals(s.find(_(' ')), 0)
 
110
        self.assertEquals(s.find(SUBSTR), 0)
 
111
        self.assertEquals(s.find(_(' '), sublen), sublen + size)
 
112
        self.assertEquals(s.find(SUBSTR, len(SUBSTR)), sublen + size)
 
113
        self.assertEquals(s.find(_('i')), SUBSTR.find(_('i')))
 
114
        self.assertEquals(s.find(_('i'), sublen),
 
115
                         sublen + size + SUBSTR.find(_('i')))
 
116
        self.assertEquals(s.find(_('i'), size),
 
117
                         sublen + size + SUBSTR.find(_('i')))
 
118
        self.assertEquals(s.find(_('j')), -1)
 
119
 
 
120
    @bigmemtest(minsize=_2G, memuse=2)
 
121
    def test_index(self, size):
 
122
        _ = self.from_latin1
 
123
        SUBSTR = _(' abc def ghi')
 
124
        sublen = len(SUBSTR)
 
125
        s = _('').join([SUBSTR, _('-') * size, SUBSTR])
 
126
        self.assertEquals(s.index(_(' ')), 0)
 
127
        self.assertEquals(s.index(SUBSTR), 0)
 
128
        self.assertEquals(s.index(_(' '), sublen), sublen + size)
 
129
        self.assertEquals(s.index(SUBSTR, sublen), sublen + size)
 
130
        self.assertEquals(s.index(_('i')), SUBSTR.index(_('i')))
 
131
        self.assertEquals(s.index(_('i'), sublen),
 
132
                         sublen + size + SUBSTR.index(_('i')))
 
133
        self.assertEquals(s.index(_('i'), size),
 
134
                         sublen + size + SUBSTR.index(_('i')))
 
135
        self.assertRaises(ValueError, s.index, _('j'))
 
136
 
 
137
    @bigmemtest(minsize=_2G, memuse=2)
 
138
    def test_isalnum(self, size):
 
139
        _ = self.from_latin1
 
140
        SUBSTR = _('123456')
 
141
        s = _('a') * size + SUBSTR
 
142
        self.failUnless(s.isalnum())
 
143
        s += _('.')
 
144
        self.failIf(s.isalnum())
 
145
 
 
146
    @bigmemtest(minsize=_2G, memuse=2)
 
147
    def test_isalpha(self, size):
 
148
        _ = self.from_latin1
 
149
        SUBSTR = _('zzzzzzz')
 
150
        s = _('a') * size + SUBSTR
 
151
        self.failUnless(s.isalpha())
 
152
        s += _('.')
 
153
        self.failIf(s.isalpha())
 
154
 
 
155
    @bigmemtest(minsize=_2G, memuse=2)
 
156
    def test_isdigit(self, size):
 
157
        _ = self.from_latin1
 
158
        SUBSTR = _('123456')
 
159
        s = _('9') * size + SUBSTR
 
160
        self.failUnless(s.isdigit())
 
161
        s += _('z')
 
162
        self.failIf(s.isdigit())
 
163
 
 
164
    @bigmemtest(minsize=_2G, memuse=2)
 
165
    def test_islower(self, size):
 
166
        _ = self.from_latin1
 
167
        chars = _(''.join(
 
168
            chr(c) for c in range(255) if not chr(c).isupper()))
 
169
        repeats = size // len(chars) + 2
 
170
        s = chars * repeats
 
171
        self.failUnless(s.islower())
 
172
        s += _('A')
 
173
        self.failIf(s.islower())
 
174
 
 
175
    @bigmemtest(minsize=_2G, memuse=2)
 
176
    def test_isspace(self, size):
 
177
        _ = self.from_latin1
 
178
        whitespace = _(' \f\n\r\t\v')
 
179
        repeats = size // len(whitespace) + 2
 
180
        s = whitespace * repeats
 
181
        self.failUnless(s.isspace())
 
182
        s += _('j')
 
183
        self.failIf(s.isspace())
 
184
 
 
185
    @bigmemtest(minsize=_2G, memuse=2)
 
186
    def test_istitle(self, size):
 
187
        _ = self.from_latin1
 
188
        SUBSTR = _('123456')
 
189
        s = _('').join([_('A'), _('a') * size, SUBSTR])
 
190
        self.failUnless(s.istitle())
 
191
        s += _('A')
 
192
        self.failUnless(s.istitle())
 
193
        s += _('aA')
 
194
        self.failIf(s.istitle())
 
195
 
 
196
    @bigmemtest(minsize=_2G, memuse=2)
 
197
    def test_isupper(self, size):
 
198
        _ = self.from_latin1
 
199
        chars = _(''.join(
 
200
            chr(c) for c in range(255) if not chr(c).islower()))
 
201
        repeats = size // len(chars) + 2
 
202
        s = chars * repeats
 
203
        self.failUnless(s.isupper())
 
204
        s += _('a')
 
205
        self.failIf(s.isupper())
 
206
 
 
207
    @bigmemtest(minsize=_2G, memuse=2)
 
208
    def test_join(self, size):
 
209
        _ = self.from_latin1
 
210
        s = _('A') * size
 
211
        x = s.join([_('aaaaa'), _('bbbbb')])
 
212
        self.assertEquals(x.count(_('a')), 5)
 
213
        self.assertEquals(x.count(_('b')), 5)
 
214
        self.failUnless(x.startswith(_('aaaaaA')))
 
215
        self.failUnless(x.endswith(_('Abbbbb')))
 
216
 
 
217
    @bigmemtest(minsize=_2G + 10, memuse=1)
 
218
    def test_ljust(self, size):
 
219
        _ = self.from_latin1
 
220
        SUBSTR = _(' abc def ghi')
 
221
        s = SUBSTR.ljust(size)
 
222
        self.failUnless(s.startswith(SUBSTR + _('  ')))
 
223
        self.assertEquals(len(s), size)
 
224
        self.assertEquals(s.strip(), SUBSTR.strip())
 
225
 
 
226
    @bigmemtest(minsize=_2G + 10, memuse=2)
 
227
    def test_lower(self, size):
 
228
        _ = self.from_latin1
 
229
        s = _('A') * size
 
230
        s = s.lower()
 
231
        self.assertEquals(len(s), size)
 
232
        self.assertEquals(s.count(_('a')), size)
 
233
 
 
234
    @bigmemtest(minsize=_2G + 10, memuse=1)
 
235
    def test_lstrip(self, size):
 
236
        _ = self.from_latin1
 
237
        SUBSTR = _('abc def ghi')
 
238
        s = SUBSTR.rjust(size)
 
239
        self.assertEquals(len(s), size)
 
240
        self.assertEquals(s.lstrip(), SUBSTR.lstrip())
 
241
        del s
 
242
        s = SUBSTR.ljust(size)
 
243
        self.assertEquals(len(s), size)
 
244
        # Type-specific optimization
 
245
        if isinstance(s, (str, bytes)):
 
246
            stripped = s.lstrip()
 
247
            self.failUnless(stripped is s)
 
248
 
 
249
    @bigmemtest(minsize=_2G + 10, memuse=2)
 
250
    def test_replace(self, size):
 
251
        _ = self.from_latin1
 
252
        replacement = _('a')
 
253
        s = _(' ') * size
 
254
        s = s.replace(_(' '), replacement)
 
255
        self.assertEquals(len(s), size)
 
256
        self.assertEquals(s.count(replacement), size)
 
257
        s = s.replace(replacement, _(' '), size - 4)
 
258
        self.assertEquals(len(s), size)
 
259
        self.assertEquals(s.count(replacement), 4)
 
260
        self.assertEquals(s[-10:], _('      aaaa'))
 
261
 
 
262
    @bigmemtest(minsize=_2G, memuse=2)
 
263
    def test_rfind(self, size):
 
264
        _ = self.from_latin1
 
265
        SUBSTR = _(' abc def ghi')
 
266
        sublen = len(SUBSTR)
 
267
        s = _('').join([SUBSTR, _('-') * size, SUBSTR])
 
268
        self.assertEquals(s.rfind(_(' ')), sublen + size + SUBSTR.rfind(_(' ')))
 
269
        self.assertEquals(s.rfind(SUBSTR), sublen + size)
 
270
        self.assertEquals(s.rfind(_(' '), 0, size), SUBSTR.rfind(_(' ')))
 
271
        self.assertEquals(s.rfind(SUBSTR, 0, sublen + size), 0)
 
272
        self.assertEquals(s.rfind(_('i')), sublen + size + SUBSTR.rfind(_('i')))
 
273
        self.assertEquals(s.rfind(_('i'), 0, sublen), SUBSTR.rfind(_('i')))
 
274
        self.assertEquals(s.rfind(_('i'), 0, sublen + size),
 
275
                          SUBSTR.rfind(_('i')))
 
276
        self.assertEquals(s.rfind(_('j')), -1)
 
277
 
 
278
    @bigmemtest(minsize=_2G, memuse=2)
 
279
    def test_rindex(self, size):
 
280
        _ = self.from_latin1
 
281
        SUBSTR = _(' abc def ghi')
 
282
        sublen = len(SUBSTR)
 
283
        s = _('').join([SUBSTR, _('-') * size, SUBSTR])
 
284
        self.assertEquals(s.rindex(_(' ')),
 
285
                          sublen + size + SUBSTR.rindex(_(' ')))
 
286
        self.assertEquals(s.rindex(SUBSTR), sublen + size)
 
287
        self.assertEquals(s.rindex(_(' '), 0, sublen + size - 1),
 
288
                          SUBSTR.rindex(_(' ')))
 
289
        self.assertEquals(s.rindex(SUBSTR, 0, sublen + size), 0)
 
290
        self.assertEquals(s.rindex(_('i')),
 
291
                          sublen + size + SUBSTR.rindex(_('i')))
 
292
        self.assertEquals(s.rindex(_('i'), 0, sublen), SUBSTR.rindex(_('i')))
 
293
        self.assertEquals(s.rindex(_('i'), 0, sublen + size),
 
294
                          SUBSTR.rindex(_('i')))
 
295
        self.assertRaises(ValueError, s.rindex, _('j'))
 
296
 
 
297
    @bigmemtest(minsize=_2G + 10, memuse=1)
 
298
    def test_rjust(self, size):
 
299
        _ = self.from_latin1
 
300
        SUBSTR = _(' abc def ghi')
 
301
        s = SUBSTR.ljust(size)
 
302
        self.failUnless(s.startswith(SUBSTR + _('  ')))
 
303
        self.assertEquals(len(s), size)
 
304
        self.assertEquals(s.strip(), SUBSTR.strip())
 
305
 
 
306
    @bigmemtest(minsize=_2G + 10, memuse=1)
 
307
    def test_rstrip(self, size):
 
308
        _ = self.from_latin1
 
309
        SUBSTR = _(' abc def ghi')
 
310
        s = SUBSTR.ljust(size)
 
311
        self.assertEquals(len(s), size)
 
312
        self.assertEquals(s.rstrip(), SUBSTR.rstrip())
 
313
        del s
 
314
        s = SUBSTR.rjust(size)
 
315
        self.assertEquals(len(s), size)
 
316
        # Type-specific optimization
 
317
        if isinstance(s, (str, bytes)):
 
318
            stripped = s.rstrip()
 
319
            self.failUnless(stripped is s)
 
320
 
 
321
    # The test takes about size bytes to build a string, and then about
 
322
    # sqrt(size) substrings of sqrt(size) in size and a list to
 
323
    # hold sqrt(size) items. It's close but just over 2x size.
 
324
    @bigmemtest(minsize=_2G, memuse=2.1)
 
325
    def test_split_small(self, size):
 
326
        _ = self.from_latin1
 
327
        # Crudely calculate an estimate so that the result of s.split won't
 
328
        # take up an inordinate amount of memory
 
329
        chunksize = int(size ** 0.5 + 2)
 
330
        SUBSTR = _('a') + _(' ') * chunksize
 
331
        s = SUBSTR * chunksize
 
332
        l = s.split()
 
333
        self.assertEquals(len(l), chunksize)
 
334
        expected = _('a')
 
335
        for item in l:
 
336
            self.assertEquals(item, expected)
 
337
        del l
 
338
        l = s.split(_('a'))
 
339
        self.assertEquals(len(l), chunksize + 1)
 
340
        expected = _(' ') * chunksize
 
341
        for item in filter(None, l):
 
342
            self.assertEquals(item, expected)
 
343
 
 
344
    # Allocates a string of twice size (and briefly two) and a list of
 
345
    # size.  Because of internal affairs, the s.split() call produces a
 
346
    # list of size times the same one-character string, so we only
 
347
    # suffer for the list size. (Otherwise, it'd cost another 48 times
 
348
    # size in bytes!) Nevertheless, a list of size takes
 
349
    # 8*size bytes.
 
350
    @bigmemtest(minsize=_2G + 5, memuse=10)
 
351
    def test_split_large(self, size):
 
352
        _ = self.from_latin1
 
353
        s = _(' a') * size + _(' ')
 
354
        l = s.split()
 
355
        self.assertEquals(len(l), size)
 
356
        self.assertEquals(set(l), set([_('a')]))
 
357
        del l
 
358
        l = s.split(_('a'))
 
359
        self.assertEquals(len(l), size + 1)
 
360
        self.assertEquals(set(l), set([_(' ')]))
 
361
 
 
362
    @bigmemtest(minsize=_2G, memuse=2.1)
 
363
    def test_splitlines(self, size):
 
364
        _ = self.from_latin1
 
365
        # Crudely calculate an estimate so that the result of s.split won't
 
366
        # take up an inordinate amount of memory
 
367
        chunksize = int(size ** 0.5 + 2) // 2
 
368
        SUBSTR = _(' ') * chunksize + _('\n') + _(' ') * chunksize + _('\r\n')
 
369
        s = SUBSTR * chunksize
 
370
        l = s.splitlines()
 
371
        self.assertEquals(len(l), chunksize * 2)
 
372
        expected = _(' ') * chunksize
 
373
        for item in l:
 
374
            self.assertEquals(item, expected)
 
375
 
 
376
    @bigmemtest(minsize=_2G, memuse=2)
 
377
    def test_startswith(self, size):
 
378
        _ = self.from_latin1
 
379
        SUBSTR = _(' abc def ghi')
 
380
        s = _('-') * size + SUBSTR
 
381
        self.failUnless(s.startswith(s))
 
382
        self.failUnless(s.startswith(_('-') * size))
 
383
        self.failIf(s.startswith(SUBSTR))
 
384
 
 
385
    @bigmemtest(minsize=_2G, memuse=1)
 
386
    def test_strip(self, size):
 
387
        _ = self.from_latin1
 
388
        SUBSTR = _('   abc def ghi   ')
 
389
        s = SUBSTR.rjust(size)
 
390
        self.assertEquals(len(s), size)
 
391
        self.assertEquals(s.strip(), SUBSTR.strip())
 
392
        del s
 
393
        s = SUBSTR.ljust(size)
 
394
        self.assertEquals(len(s), size)
 
395
        self.assertEquals(s.strip(), SUBSTR.strip())
 
396
 
 
397
    @bigmemtest(minsize=_2G, memuse=2)
 
398
    def test_swapcase(self, size):
 
399
        _ = self.from_latin1
 
400
        SUBSTR = _("aBcDeFG12.'\xa9\x00")
 
401
        sublen = len(SUBSTR)
 
402
        repeats = size // sublen + 2
 
403
        s = SUBSTR * repeats
 
404
        s = s.swapcase()
 
405
        self.assertEquals(len(s), sublen * repeats)
 
406
        self.assertEquals(s[:sublen * 3], SUBSTR.swapcase() * 3)
 
407
        self.assertEquals(s[-sublen * 3:], SUBSTR.swapcase() * 3)
 
408
 
 
409
    @bigmemtest(minsize=_2G, memuse=2)
 
410
    def test_title(self, size):
 
411
        _ = self.from_latin1
 
412
        SUBSTR = _('SpaaHAaaAaham')
 
413
        s = SUBSTR * (size // len(SUBSTR) + 2)
 
414
        s = s.title()
 
415
        self.failUnless(s.startswith((SUBSTR * 3).title()))
 
416
        self.failUnless(s.endswith(SUBSTR.lower() * 3))
 
417
 
 
418
    @bigmemtest(minsize=_2G, memuse=2)
 
419
    def test_translate(self, size):
 
420
        _ = self.from_latin1
 
421
        trans = {
 
422
            ord(_('.')): _('-'),
 
423
            ord(_('a')): _('!'),
 
424
            ord(_('Z')): _('$'),
 
425
        }
 
426
        SUBSTR = _('aZz.z.Aaz.')
 
427
        if not isinstance(SUBSTR, str):
 
428
            # Workaround the inexistence of bytes.maketrans()
 
429
            chars = bytearray(range(256))
 
430
            for k, v in trans.items():
 
431
                chars[k] = ord(v)
 
432
            trans = chars
 
433
        sublen = len(SUBSTR)
 
434
        repeats = size // sublen + 2
 
435
        s = SUBSTR * repeats
 
436
        s = s.translate(trans)
 
437
        self.assertEquals(len(s), repeats * sublen)
 
438
        self.assertEquals(s[:sublen], SUBSTR.translate(trans))
 
439
        self.assertEquals(s[-sublen:], SUBSTR.translate(trans))
 
440
        self.assertEquals(s.count(_('.')), 0)
 
441
        self.assertEquals(s.count(_('!')), repeats * 2)
 
442
        self.assertEquals(s.count(_('z')), repeats * 3)
 
443
 
 
444
    @bigmemtest(minsize=_2G + 5, memuse=2)
 
445
    def test_upper(self, size):
 
446
        _ = self.from_latin1
 
447
        s = _('a') * size
 
448
        s = s.upper()
 
449
        self.assertEquals(len(s), size)
 
450
        self.assertEquals(s.count(_('A')), size)
 
451
 
 
452
    @bigmemtest(minsize=_2G + 20, memuse=1)
 
453
    def test_zfill(self, size):
 
454
        _ = self.from_latin1
 
455
        SUBSTR = _('-568324723598234')
 
456
        s = SUBSTR.zfill(size)
 
457
        self.failUnless(s.endswith(_('0') + SUBSTR[1:]))
 
458
        self.failUnless(s.startswith(_('-0')))
 
459
        self.assertEquals(len(s), size)
 
460
        self.assertEquals(s.count(_('0')), size - len(SUBSTR))
 
461
 
 
462
    # This test is meaningful even with size < 2G, as long as the
 
463
    # doubled string is > 2G (but it tests more if both are > 2G :)
 
464
    @bigmemtest(minsize=_1G + 2, memuse=3)
 
465
    def test_concat(self, size):
 
466
        _ = self.from_latin1
 
467
        s = _('.') * size
 
468
        self.assertEquals(len(s), size)
 
469
        s = s + s
 
470
        self.assertEquals(len(s), size * 2)
 
471
        self.assertEquals(s.count(_('.')), size * 2)
 
472
 
 
473
    # This test is meaningful even with size < 2G, as long as the
 
474
    # repeated string is > 2G (but it tests more if both are > 2G :)
 
475
    @bigmemtest(minsize=_1G + 2, memuse=3)
 
476
    def test_repeat(self, size):
 
477
        _ = self.from_latin1
 
478
        s = _('.') * size
 
479
        self.assertEquals(len(s), size)
 
480
        s = s * 2
 
481
        self.assertEquals(len(s), size * 2)
 
482
        self.assertEquals(s.count(_('.')), size * 2)
 
483
 
 
484
    @bigmemtest(minsize=_2G + 20, memuse=2)
 
485
    def test_slice_and_getitem(self, size):
 
486
        _ = self.from_latin1
 
487
        SUBSTR = _('0123456789')
 
488
        sublen = len(SUBSTR)
 
489
        s = SUBSTR * (size // sublen)
 
490
        stepsize = len(s) // 100
 
491
        stepsize = stepsize - (stepsize % sublen)
 
492
        for i in range(0, len(s) - stepsize, stepsize):
 
493
            self.assertEquals(s[i], SUBSTR[0])
 
494
            self.assertEquals(s[i:i + sublen], SUBSTR)
 
495
            self.assertEquals(s[i:i + sublen:2], SUBSTR[::2])
 
496
            if i > 0:
 
497
                self.assertEquals(s[i + sublen - 1:i - 1:-3],
 
498
                                  SUBSTR[sublen::-3])
 
499
        # Make sure we do some slicing and indexing near the end of the
 
500
        # string, too.
 
501
        self.assertEquals(s[len(s) - 1], SUBSTR[-1])
 
502
        self.assertEquals(s[-1], SUBSTR[-1])
 
503
        self.assertEquals(s[len(s) - 10], SUBSTR[0])
 
504
        self.assertEquals(s[-sublen], SUBSTR[0])
 
505
        self.assertEquals(s[len(s):], _(''))
 
506
        self.assertEquals(s[len(s) - 1:], SUBSTR[-1:])
 
507
        self.assertEquals(s[-1:], SUBSTR[-1:])
 
508
        self.assertEquals(s[len(s) - sublen:], SUBSTR)
 
509
        self.assertEquals(s[-sublen:], SUBSTR)
 
510
        self.assertEquals(len(s[:]), len(s))
 
511
        self.assertEquals(len(s[:len(s) - 5]), len(s) - 5)
 
512
        self.assertEquals(len(s[5:-5]), len(s) - 10)
 
513
 
 
514
        self.assertRaises(IndexError, operator.getitem, s, len(s))
 
515
        self.assertRaises(IndexError, operator.getitem, s, len(s) + 1)
 
516
        self.assertRaises(IndexError, operator.getitem, s, len(s) + 1<<31)
 
517
 
 
518
    @bigmemtest(minsize=_2G, memuse=2)
 
519
    def test_contains(self, size):
 
520
        _ = self.from_latin1
 
521
        SUBSTR = _('0123456789')
 
522
        edge = _('-') * (size // 2)
 
523
        s = _('').join([edge, SUBSTR, edge])
 
524
        del edge
 
525
        self.failUnless(SUBSTR in s)
 
526
        self.failIf(SUBSTR * 2 in s)
 
527
        self.failUnless(_('-') in s)
 
528
        self.failIf(_('a') in s)
 
529
        s += _('a')
 
530
        self.failUnless(_('a') in s)
 
531
 
 
532
    @bigmemtest(minsize=_2G + 10, memuse=2)
 
533
    def test_compare(self, size):
 
534
        _ = self.from_latin1
 
535
        s1 = _('-') * size
 
536
        s2 = _('-') * size
 
537
        self.assertEqual(s1, s2)
 
538
        del s2
 
539
        s2 = s1 + _('a')
 
540
        self.failIf(s1 == s2)
 
541
        del s2
 
542
        s2 = _('.') * size
 
543
        self.failIf(s1 == s2)
 
544
 
 
545
    @bigmemtest(minsize=_2G + 10, memuse=1)
 
546
    def test_hash(self, size):
 
547
        # Not sure if we can do any meaningful tests here...  Even if we
 
548
        # start relying on the exact algorithm used, the result will be
 
549
        # different depending on the size of the C 'long int'.  Even this
 
550
        # test is dodgy (there's no *guarantee* that the two things should
 
551
        # have a different hash, even if they, in the current
 
552
        # implementation, almost always do.)
 
553
        _ = self.from_latin1
 
554
        s = _('\x00') * size
 
555
        h1 = hash(s)
 
556
        del s
 
557
        s = _('\x00') * (size + 1)
 
558
        self.failIf(h1 == hash(s))
 
559
 
 
560
 
 
561
class StrTest(unittest.TestCase, BaseStrTest):
 
562
 
 
563
    def from_latin1(self, s):
 
564
        return s
 
565
 
 
566
    def basic_encode_test(self, size, enc, c='.', expectedsize=None):
 
567
        if expectedsize is None:
 
568
            expectedsize = size
 
569
 
 
570
        s = c * size
 
571
        self.assertEquals(len(s.encode(enc)), expectedsize)
 
572
 
 
573
    def setUp(self):
 
574
        # HACK: adjust memory use of tests inherited from BaseStrTest
 
575
        # according to character size.
 
576
        self._adjusted = {}
 
577
        for name in dir(BaseStrTest):
 
578
            if not name.startswith('test_'):
 
579
                continue
 
580
            meth = getattr(type(self), name)
 
581
            try:
 
582
                memuse = meth.memuse
 
583
            except AttributeError:
 
584
                continue
 
585
            meth.memuse = character_size * memuse
 
586
            self._adjusted[name] = memuse
 
587
 
 
588
    def tearDown(self):
 
589
        for name, memuse in self._adjusted.items():
 
590
            getattr(type(self), name).memuse = memuse
 
591
 
 
592
    @bigmemtest(minsize=_2G + 2, memuse=character_size + 1)
 
593
    def test_encode(self, size):
 
594
        return self.basic_encode_test(size, 'utf-8')
 
595
 
 
596
    @precisionbigmemtest(size=_4G // 6 + 2, memuse=character_size + 1)
 
597
    def test_encode_raw_unicode_escape(self, size):
 
598
        try:
 
599
            return self.basic_encode_test(size, 'raw_unicode_escape')
 
600
        except MemoryError:
 
601
            pass # acceptable on 32-bit
 
602
 
 
603
    @precisionbigmemtest(size=_4G // 5 + 70, memuse=character_size + 1)
 
604
    def test_encode_utf7(self, size):
 
605
        try:
 
606
            return self.basic_encode_test(size, 'utf7')
 
607
        except MemoryError:
 
608
            pass # acceptable on 32-bit
 
609
 
 
610
    @precisionbigmemtest(size=_4G // 4 + 5, memuse=character_size + 4)
 
611
    def test_encode_utf32(self, size):
 
612
        try:
 
613
            return self.basic_encode_test(size, 'utf32', expectedsize=4*size+4)
 
614
        except MemoryError:
 
615
            pass # acceptable on 32-bit
 
616
 
 
617
    @precisionbigmemtest(size=_2G - 1, memuse=character_size + 1)
 
618
    def test_encode_ascii(self, size):
 
619
        return self.basic_encode_test(size, 'ascii', c='A')
 
620
 
 
621
    @precisionbigmemtest(size=_4G // 5, memuse=character_size * (6 + 1))
 
622
    def test_unicode_repr_overflow(self, size):
 
623
        try:
 
624
            s = "\uAAAA"*size
 
625
            r = repr(s)
 
626
        except MemoryError:
 
627
            pass # acceptable on 32-bit
 
628
        else:
 
629
            self.failUnless(s == eval(r))
 
630
 
 
631
    @bigmemtest(minsize=_2G + 10, memuse=character_size * 2)
 
632
    def test_format(self, size):
 
633
        s = '-' * size
 
634
        sf = '%s' % (s,)
 
635
        self.assertEqual(s, sf)
 
636
        del sf
 
637
        sf = '..%s..' % (s,)
 
638
        self.assertEquals(len(sf), len(s) + 4)
 
639
        self.failUnless(sf.startswith('..-'))
 
640
        self.failUnless(sf.endswith('-..'))
 
641
        del s, sf
 
642
 
 
643
        size //= 2
 
644
        edge = '-' * size
 
645
        s = ''.join([edge, '%s', edge])
 
646
        del edge
 
647
        s = s % '...'
 
648
        self.assertEquals(len(s), size * 2 + 3)
 
649
        self.assertEquals(s.count('.'), 3)
 
650
        self.assertEquals(s.count('-'), size * 2)
 
651
 
 
652
    @bigmemtest(minsize=_2G + 10, memuse=character_size * 2)
 
653
    def test_repr_small(self, size):
 
654
        s = '-' * size
 
655
        s = repr(s)
 
656
        self.assertEquals(len(s), size + 2)
 
657
        self.assertEquals(s[0], "'")
 
658
        self.assertEquals(s[-1], "'")
 
659
        self.assertEquals(s.count('-'), size)
 
660
        del s
 
661
        # repr() will create a string four times as large as this 'binary
 
662
        # string', but we don't want to allocate much more than twice
 
663
        # size in total.  (We do extra testing in test_repr_large())
 
664
        size = size // 5 * 2
 
665
        s = '\x00' * size
 
666
        s = repr(s)
 
667
        self.assertEquals(len(s), size * 4 + 2)
 
668
        self.assertEquals(s[0], "'")
 
669
        self.assertEquals(s[-1], "'")
 
670
        self.assertEquals(s.count('\\'), size)
 
671
        self.assertEquals(s.count('0'), size * 2)
 
672
 
 
673
    @bigmemtest(minsize=_2G + 10, memuse=character_size * 5)
 
674
    def test_repr_large(self, size):
 
675
        s = '\x00' * size
 
676
        s = repr(s)
 
677
        self.assertEquals(len(s), size * 4 + 2)
 
678
        self.assertEquals(s[0], "'")
 
679
        self.assertEquals(s[-1], "'")
 
680
        self.assertEquals(s.count('\\'), size)
 
681
        self.assertEquals(s.count('0'), size * 2)
 
682
 
 
683
    @bigmemtest(minsize=2**32 / 5, memuse=character_size * 7)
 
684
    def test_unicode_repr(self, size):
 
685
        s = "\uAAAA" * size
 
686
        for f in (repr, ascii):
 
687
            r = f(s)
 
688
            self.failUnless(len(r) > size)
 
689
            self.failUnless(r.endswith(r"\uaaaa'"), r[-10:])
 
690
            del r
 
691
 
 
692
    # The character takes 4 bytes even in UCS-2 builds because it will
 
693
    # be decomposed into surrogates.
 
694
    @bigmemtest(minsize=2**32 / 5, memuse=4 + character_size * 9)
 
695
    def test_unicode_repr_wide(self, size):
 
696
        s = "\U0001AAAA" * size
 
697
        for f in (repr, ascii):
 
698
            r = f(s)
 
699
            self.failUnless(len(r) > size)
 
700
            self.failUnless(r.endswith(r"\U0001aaaa'"), r[-12:])
 
701
            del r
 
702
 
 
703
 
 
704
class BytesTest(unittest.TestCase, BaseStrTest):
 
705
 
 
706
    def from_latin1(self, s):
 
707
        return s.encode("latin1")
 
708
 
 
709
    @bigmemtest(minsize=_2G + 2, memuse=1 + character_size)
 
710
    def test_decode(self, size):
 
711
        s = self.from_latin1('.') * size
 
712
        self.assertEquals(len(s.decode('utf-8')), size)
 
713
 
 
714
 
 
715
class BytearrayTest(unittest.TestCase, BaseStrTest):
 
716
 
 
717
    def from_latin1(self, s):
 
718
        return bytearray(s.encode("latin1"))
 
719
 
 
720
    @bigmemtest(minsize=_2G + 2, memuse=1 + character_size)
 
721
    def test_decode(self, size):
 
722
        s = self.from_latin1('.') * size
 
723
        self.assertEquals(len(s.decode('utf-8')), size)
 
724
 
 
725
    test_hash = None
 
726
    test_split_large = None
 
727
 
 
728
class TupleTest(unittest.TestCase):
 
729
 
 
730
    # Tuples have a small, fixed-sized head and an array of pointers to
 
731
    # data.  Since we're testing 64-bit addressing, we can assume that the
 
732
    # pointers are 8 bytes, and that thus that the tuples take up 8 bytes
 
733
    # per size.
 
734
 
 
735
    # As a side-effect of testing long tuples, these tests happen to test
 
736
    # having more than 2<<31 references to any given object. Hence the
 
737
    # use of different types of objects as contents in different tests.
 
738
 
 
739
    @bigmemtest(minsize=_2G + 2, memuse=16)
 
740
    def test_compare(self, size):
 
741
        t1 = ('',) * size
 
742
        t2 = ('',) * size
 
743
        self.assertEqual(t1, t2)
 
744
        del t2
 
745
        t2 = ('',) * (size + 1)
 
746
        self.failIf(t1 == t2)
 
747
        del t2
 
748
        t2 = (1,) * size
 
749
        self.failIf(t1 == t2)
 
750
 
 
751
    # Test concatenating into a single tuple of more than 2G in length,
 
752
    # and concatenating a tuple of more than 2G in length separately, so
 
753
    # the smaller test still gets run even if there isn't memory for the
 
754
    # larger test (but we still let the tester know the larger test is
 
755
    # skipped, in verbose mode.)
 
756
    def basic_concat_test(self, size):
 
757
        t = ((),) * size
 
758
        self.assertEquals(len(t), size)
 
759
        t = t + t
 
760
        self.assertEquals(len(t), size * 2)
 
761
 
 
762
    @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
 
763
    def test_concat_small(self, size):
 
764
        return self.basic_concat_test(size)
 
765
 
 
766
    @bigmemtest(minsize=_2G + 2, memuse=24)
 
767
    def test_concat_large(self, size):
 
768
        return self.basic_concat_test(size)
 
769
 
 
770
    @bigmemtest(minsize=_2G // 5 + 10, memuse=8 * 5)
 
771
    def test_contains(self, size):
 
772
        t = (1, 2, 3, 4, 5) * size
 
773
        self.assertEquals(len(t), size * 5)
 
774
        self.failUnless(5 in t)
 
775
        self.failIf((1, 2, 3, 4, 5) in t)
 
776
        self.failIf(0 in t)
 
777
 
 
778
    @bigmemtest(minsize=_2G + 10, memuse=8)
 
779
    def test_hash(self, size):
 
780
        t1 = (0,) * size
 
781
        h1 = hash(t1)
 
782
        del t1
 
783
        t2 = (0,) * (size + 1)
 
784
        self.failIf(h1 == hash(t2))
 
785
 
 
786
    @bigmemtest(minsize=_2G + 10, memuse=8)
 
787
    def test_index_and_slice(self, size):
 
788
        t = (None,) * size
 
789
        self.assertEquals(len(t), size)
 
790
        self.assertEquals(t[-1], None)
 
791
        self.assertEquals(t[5], None)
 
792
        self.assertEquals(t[size - 1], None)
 
793
        self.assertRaises(IndexError, operator.getitem, t, size)
 
794
        self.assertEquals(t[:5], (None,) * 5)
 
795
        self.assertEquals(t[-5:], (None,) * 5)
 
796
        self.assertEquals(t[20:25], (None,) * 5)
 
797
        self.assertEquals(t[-25:-20], (None,) * 5)
 
798
        self.assertEquals(t[size - 5:], (None,) * 5)
 
799
        self.assertEquals(t[size - 5:size], (None,) * 5)
 
800
        self.assertEquals(t[size - 6:size - 2], (None,) * 4)
 
801
        self.assertEquals(t[size:size], ())
 
802
        self.assertEquals(t[size:size+5], ())
 
803
 
 
804
    # Like test_concat, split in two.
 
805
    def basic_test_repeat(self, size):
 
806
        t = ('',) * size
 
807
        self.assertEquals(len(t), size)
 
808
        t = t * 2
 
809
        self.assertEquals(len(t), size * 2)
 
810
 
 
811
    @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
 
812
    def test_repeat_small(self, size):
 
813
        return self.basic_test_repeat(size)
 
814
 
 
815
    @bigmemtest(minsize=_2G + 2, memuse=24)
 
816
    def test_repeat_large(self, size):
 
817
        return self.basic_test_repeat(size)
 
818
 
 
819
    @bigmemtest(minsize=_1G - 1, memuse=12)
 
820
    def test_repeat_large_2(self, size):
 
821
        return self.basic_test_repeat(size)
 
822
 
 
823
    @precisionbigmemtest(size=_1G - 1, memuse=9)
 
824
    def test_from_2G_generator(self, size):
 
825
        try:
 
826
            t = tuple(range(size))
 
827
        except MemoryError:
 
828
            pass # acceptable on 32-bit
 
829
        else:
 
830
            count = 0
 
831
            for item in t:
 
832
                self.assertEquals(item, count)
 
833
                count += 1
 
834
            self.assertEquals(count, size)
 
835
 
 
836
    @precisionbigmemtest(size=_1G - 25, memuse=9)
 
837
    def test_from_almost_2G_generator(self, size):
 
838
        try:
 
839
            t = tuple(range(size))
 
840
            count = 0
 
841
            for item in t:
 
842
                self.assertEquals(item, count)
 
843
                count += 1
 
844
            self.assertEquals(count, size)
 
845
        except MemoryError:
 
846
            pass # acceptable, expected on 32-bit
 
847
 
 
848
    # Like test_concat, split in two.
 
849
    def basic_test_repr(self, size):
 
850
        t = (0,) * size
 
851
        s = repr(t)
 
852
        # The repr of a tuple of 0's is exactly three times the tuple length.
 
853
        self.assertEquals(len(s), size * 3)
 
854
        self.assertEquals(s[:5], '(0, 0')
 
855
        self.assertEquals(s[-5:], '0, 0)')
 
856
        self.assertEquals(s.count('0'), size)
 
857
 
 
858
    @bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3)
 
859
    def test_repr_small(self, size):
 
860
        return self.basic_test_repr(size)
 
861
 
 
862
    @bigmemtest(minsize=_2G + 2, memuse=8 + 3)
 
863
    def test_repr_large(self, size):
 
864
        return self.basic_test_repr(size)
 
865
 
 
866
class ListTest(unittest.TestCase):
 
867
 
 
868
    # Like tuples, lists have a small, fixed-sized head and an array of
 
869
    # pointers to data, so 8 bytes per size. Also like tuples, we make the
 
870
    # lists hold references to various objects to test their refcount
 
871
    # limits.
 
872
 
 
873
    @bigmemtest(minsize=_2G + 2, memuse=16)
 
874
    def test_compare(self, size):
 
875
        l1 = [''] * size
 
876
        l2 = [''] * size
 
877
        self.assertEqual(l1, l2)
 
878
        del l2
 
879
        l2 = [''] * (size + 1)
 
880
        self.failIf(l1 == l2)
 
881
        del l2
 
882
        l2 = [2] * size
 
883
        self.failIf(l1 == l2)
 
884
 
 
885
    # Test concatenating into a single list of more than 2G in length,
 
886
    # and concatenating a list of more than 2G in length separately, so
 
887
    # the smaller test still gets run even if there isn't memory for the
 
888
    # larger test (but we still let the tester know the larger test is
 
889
    # skipped, in verbose mode.)
 
890
    def basic_test_concat(self, size):
 
891
        l = [[]] * size
 
892
        self.assertEquals(len(l), size)
 
893
        l = l + l
 
894
        self.assertEquals(len(l), size * 2)
 
895
 
 
896
    @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
 
897
    def test_concat_small(self, size):
 
898
        return self.basic_test_concat(size)
 
899
 
 
900
    @bigmemtest(minsize=_2G + 2, memuse=24)
 
901
    def test_concat_large(self, size):
 
902
        return self.basic_test_concat(size)
 
903
 
 
904
    def basic_test_inplace_concat(self, size):
 
905
        l = [sys.stdout] * size
 
906
        l += l
 
907
        self.assertEquals(len(l), size * 2)
 
908
        self.failUnless(l[0] is l[-1])
 
909
        self.failUnless(l[size - 1] is l[size + 1])
 
910
 
 
911
    @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
 
912
    def test_inplace_concat_small(self, size):
 
913
        return self.basic_test_inplace_concat(size)
 
914
 
 
915
    @bigmemtest(minsize=_2G + 2, memuse=24)
 
916
    def test_inplace_concat_large(self, size):
 
917
        return self.basic_test_inplace_concat(size)
 
918
 
 
919
    @bigmemtest(minsize=_2G // 5 + 10, memuse=8 * 5)
 
920
    def test_contains(self, size):
 
921
        l = [1, 2, 3, 4, 5] * size
 
922
        self.assertEquals(len(l), size * 5)
 
923
        self.failUnless(5 in l)
 
924
        self.failIf([1, 2, 3, 4, 5] in l)
 
925
        self.failIf(0 in l)
 
926
 
 
927
    @bigmemtest(minsize=_2G + 10, memuse=8)
 
928
    def test_hash(self, size):
 
929
        l = [0] * size
 
930
        self.failUnlessRaises(TypeError, hash, l)
 
931
 
 
932
    @bigmemtest(minsize=_2G + 10, memuse=8)
 
933
    def test_index_and_slice(self, size):
 
934
        l = [None] * size
 
935
        self.assertEquals(len(l), size)
 
936
        self.assertEquals(l[-1], None)
 
937
        self.assertEquals(l[5], None)
 
938
        self.assertEquals(l[size - 1], None)
 
939
        self.assertRaises(IndexError, operator.getitem, l, size)
 
940
        self.assertEquals(l[:5], [None] * 5)
 
941
        self.assertEquals(l[-5:], [None] * 5)
 
942
        self.assertEquals(l[20:25], [None] * 5)
 
943
        self.assertEquals(l[-25:-20], [None] * 5)
 
944
        self.assertEquals(l[size - 5:], [None] * 5)
 
945
        self.assertEquals(l[size - 5:size], [None] * 5)
 
946
        self.assertEquals(l[size - 6:size - 2], [None] * 4)
 
947
        self.assertEquals(l[size:size], [])
 
948
        self.assertEquals(l[size:size+5], [])
 
949
 
 
950
        l[size - 2] = 5
 
951
        self.assertEquals(len(l), size)
 
952
        self.assertEquals(l[-3:], [None, 5, None])
 
953
        self.assertEquals(l.count(5), 1)
 
954
        self.assertRaises(IndexError, operator.setitem, l, size, 6)
 
955
        self.assertEquals(len(l), size)
 
956
 
 
957
        l[size - 7:] = [1, 2, 3, 4, 5]
 
958
        size -= 2
 
959
        self.assertEquals(len(l), size)
 
960
        self.assertEquals(l[-7:], [None, None, 1, 2, 3, 4, 5])
 
961
 
 
962
        l[:7] = [1, 2, 3, 4, 5]
 
963
        size -= 2
 
964
        self.assertEquals(len(l), size)
 
965
        self.assertEquals(l[:7], [1, 2, 3, 4, 5, None, None])
 
966
 
 
967
        del l[size - 1]
 
968
        size -= 1
 
969
        self.assertEquals(len(l), size)
 
970
        self.assertEquals(l[-1], 4)
 
971
 
 
972
        del l[-2:]
 
973
        size -= 2
 
974
        self.assertEquals(len(l), size)
 
975
        self.assertEquals(l[-1], 2)
 
976
 
 
977
        del l[0]
 
978
        size -= 1
 
979
        self.assertEquals(len(l), size)
 
980
        self.assertEquals(l[0], 2)
 
981
 
 
982
        del l[:2]
 
983
        size -= 2
 
984
        self.assertEquals(len(l), size)
 
985
        self.assertEquals(l[0], 4)
 
986
 
 
987
    # Like test_concat, split in two.
 
988
    def basic_test_repeat(self, size):
 
989
        l = [] * size
 
990
        self.failIf(l)
 
991
        l = [''] * size
 
992
        self.assertEquals(len(l), size)
 
993
        l = l * 2
 
994
        self.assertEquals(len(l), size * 2)
 
995
 
 
996
    @bigmemtest(minsize=_2G // 2 + 2, memuse=24)
 
997
    def test_repeat_small(self, size):
 
998
        return self.basic_test_repeat(size)
 
999
 
 
1000
    @bigmemtest(minsize=_2G + 2, memuse=24)
 
1001
    def test_repeat_large(self, size):
 
1002
        return self.basic_test_repeat(size)
 
1003
 
 
1004
    def basic_test_inplace_repeat(self, size):
 
1005
        l = ['']
 
1006
        l *= size
 
1007
        self.assertEquals(len(l), size)
 
1008
        self.failUnless(l[0] is l[-1])
 
1009
        del l
 
1010
 
 
1011
        l = [''] * size
 
1012
        l *= 2
 
1013
        self.assertEquals(len(l), size * 2)
 
1014
        self.failUnless(l[size - 1] is l[-1])
 
1015
 
 
1016
    @bigmemtest(minsize=_2G // 2 + 2, memuse=16)
 
1017
    def test_inplace_repeat_small(self, size):
 
1018
        return self.basic_test_inplace_repeat(size)
 
1019
 
 
1020
    @bigmemtest(minsize=_2G + 2, memuse=16)
 
1021
    def test_inplace_repeat_large(self, size):
 
1022
        return self.basic_test_inplace_repeat(size)
 
1023
 
 
1024
    def basic_test_repr(self, size):
 
1025
        l = [0] * size
 
1026
        s = repr(l)
 
1027
        # The repr of a list of 0's is exactly three times the list length.
 
1028
        self.assertEquals(len(s), size * 3)
 
1029
        self.assertEquals(s[:5], '[0, 0')
 
1030
        self.assertEquals(s[-5:], '0, 0]')
 
1031
        self.assertEquals(s.count('0'), size)
 
1032
 
 
1033
    @bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3)
 
1034
    def test_repr_small(self, size):
 
1035
        return self.basic_test_repr(size)
 
1036
 
 
1037
    @bigmemtest(minsize=_2G + 2, memuse=8 + 3)
 
1038
    def test_repr_large(self, size):
 
1039
        return self.basic_test_repr(size)
 
1040
 
 
1041
    # list overallocates ~1/8th of the total size (on first expansion) so
 
1042
    # the single list.append call puts memuse at 9 bytes per size.
 
1043
    @bigmemtest(minsize=_2G, memuse=9)
 
1044
    def test_append(self, size):
 
1045
        l = [object()] * size
 
1046
        l.append(object())
 
1047
        self.assertEquals(len(l), size+1)
 
1048
        self.failUnless(l[-3] is l[-2])
 
1049
        self.failIf(l[-2] is l[-1])
 
1050
 
 
1051
    @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
 
1052
    def test_count(self, size):
 
1053
        l = [1, 2, 3, 4, 5] * size
 
1054
        self.assertEquals(l.count(1), size)
 
1055
        self.assertEquals(l.count("1"), 0)
 
1056
 
 
1057
    def basic_test_extend(self, size):
 
1058
        l = [object] * size
 
1059
        l.extend(l)
 
1060
        self.assertEquals(len(l), size * 2)
 
1061
        self.failUnless(l[0] is l[-1])
 
1062
        self.failUnless(l[size - 1] is l[size + 1])
 
1063
 
 
1064
    @bigmemtest(minsize=_2G // 2 + 2, memuse=16)
 
1065
    def test_extend_small(self, size):
 
1066
        return self.basic_test_extend(size)
 
1067
 
 
1068
    @bigmemtest(minsize=_2G + 2, memuse=16)
 
1069
    def test_extend_large(self, size):
 
1070
        return self.basic_test_extend(size)
 
1071
 
 
1072
    @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
 
1073
    def test_index(self, size):
 
1074
        l = [1, 2, 3, 4, 5] * size
 
1075
        size *= 5
 
1076
        self.assertEquals(l.index(1), 0)
 
1077
        self.assertEquals(l.index(5, size - 5), size - 1)
 
1078
        self.assertEquals(l.index(5, size - 5, size), size - 1)
 
1079
        self.assertRaises(ValueError, l.index, 1, size - 4, size)
 
1080
        self.assertRaises(ValueError, l.index, 6)
 
1081
 
 
1082
    # This tests suffers from overallocation, just like test_append.
 
1083
    @bigmemtest(minsize=_2G + 10, memuse=9)
 
1084
    def test_insert(self, size):
 
1085
        l = [1.0] * size
 
1086
        l.insert(size - 1, "A")
 
1087
        size += 1
 
1088
        self.assertEquals(len(l), size)
 
1089
        self.assertEquals(l[-3:], [1.0, "A", 1.0])
 
1090
 
 
1091
        l.insert(size + 1, "B")
 
1092
        size += 1
 
1093
        self.assertEquals(len(l), size)
 
1094
        self.assertEquals(l[-3:], ["A", 1.0, "B"])
 
1095
 
 
1096
        l.insert(1, "C")
 
1097
        size += 1
 
1098
        self.assertEquals(len(l), size)
 
1099
        self.assertEquals(l[:3], [1.0, "C", 1.0])
 
1100
        self.assertEquals(l[size - 3:], ["A", 1.0, "B"])
 
1101
 
 
1102
    @bigmemtest(minsize=_2G // 5 + 4, memuse=8 * 5)
 
1103
    def test_pop(self, size):
 
1104
        l = ["a", "b", "c", "d", "e"] * size
 
1105
        size *= 5
 
1106
        self.assertEquals(len(l), size)
 
1107
 
 
1108
        item = l.pop()
 
1109
        size -= 1
 
1110
        self.assertEquals(len(l), size)
 
1111
        self.assertEquals(item, "e")
 
1112
        self.assertEquals(l[-2:], ["c", "d"])
 
1113
 
 
1114
        item = l.pop(0)
 
1115
        size -= 1
 
1116
        self.assertEquals(len(l), size)
 
1117
        self.assertEquals(item, "a")
 
1118
        self.assertEquals(l[:2], ["b", "c"])
 
1119
 
 
1120
        item = l.pop(size - 2)
 
1121
        size -= 1
 
1122
        self.assertEquals(len(l), size)
 
1123
        self.assertEquals(item, "c")
 
1124
        self.assertEquals(l[-2:], ["b", "d"])
 
1125
 
 
1126
    @bigmemtest(minsize=_2G + 10, memuse=8)
 
1127
    def test_remove(self, size):
 
1128
        l = [10] * size
 
1129
        self.assertEquals(len(l), size)
 
1130
 
 
1131
        l.remove(10)
 
1132
        size -= 1
 
1133
        self.assertEquals(len(l), size)
 
1134
 
 
1135
        # Because of the earlier l.remove(), this append doesn't trigger
 
1136
        # a resize.
 
1137
        l.append(5)
 
1138
        size += 1
 
1139
        self.assertEquals(len(l), size)
 
1140
        self.assertEquals(l[-2:], [10, 5])
 
1141
        l.remove(5)
 
1142
        size -= 1
 
1143
        self.assertEquals(len(l), size)
 
1144
        self.assertEquals(l[-2:], [10, 10])
 
1145
 
 
1146
    @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
 
1147
    def test_reverse(self, size):
 
1148
        l = [1, 2, 3, 4, 5] * size
 
1149
        l.reverse()
 
1150
        self.assertEquals(len(l), size * 5)
 
1151
        self.assertEquals(l[-5:], [5, 4, 3, 2, 1])
 
1152
        self.assertEquals(l[:5], [5, 4, 3, 2, 1])
 
1153
 
 
1154
    @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5)
 
1155
    def test_sort(self, size):
 
1156
        l = [1, 2, 3, 4, 5] * size
 
1157
        l.sort()
 
1158
        self.assertEquals(len(l), size * 5)
 
1159
        self.assertEquals(l.count(1), size)
 
1160
        self.assertEquals(l[:10], [1] * 10)
 
1161
        self.assertEquals(l[-10:], [5] * 10)
 
1162
 
 
1163
def test_main():
 
1164
    support.run_unittest(StrTest, BytesTest, BytearrayTest,
 
1165
        TupleTest, ListTest)
 
1166
 
 
1167
if __name__ == '__main__':
 
1168
    if len(sys.argv) > 1:
 
1169
        support.set_memlimit(sys.argv[1])
 
1170
    test_main()