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