72     def _test_capitalize(self, size):  argument
75         s = _('-') * size + SUBSTR
81     @bigmemtest(size=_2G + 10, memuse=1)
82     def test_center(self, size):  argument
84         s = SUBSTR.center(size)
85         self.assertEqual(len(s), size)
92     @bigmemtest(size=_2G, memuse=2)
93     def test_count(self, size):  argument
96         s = _('.') * size + SUBSTR
97         self.assertEqual(s.count(_('.')), size)
99         self.assertEqual(s.count(_('.')), size + 1)
104     @bigmemtest(size=_2G, memuse=2)
105     def test_endswith(self, size):  argument
108         s = _('-') * size + SUBSTR
116     @bigmemtest(size=_2G + 10, memuse=2)
117     def test_expandtabs(self, size):  argument
119         s = _('-') * size
123         slen, remainder = divmod(size, tabsize)
126         self.assertEqual(len(s), size - remainder)
129     @bigmemtest(size=_2G, memuse=2)
130     def test_find(self, size):  argument
134         s = _('').join([SUBSTR, _('-') * size, SUBSTR])
137         self.assertEqual(s.find(_(' '), sublen), sublen + size)
138         self.assertEqual(s.find(SUBSTR, len(SUBSTR)), sublen + size)
141                          sublen + size + SUBSTR.find(_('i')))
142         self.assertEqual(s.find(_('i'), size),
143                          sublen + size + SUBSTR.find(_('i')))
146     @bigmemtest(size=_2G, memuse=2)
147     def test_index(self, size):  argument
151         s = _('').join([SUBSTR, _('-') * size, SUBSTR])
154         self.assertEqual(s.index(_(' '), sublen), sublen + size)
155         self.assertEqual(s.index(SUBSTR, sublen), sublen + size)
158                          sublen + size + SUBSTR.index(_('i')))
159         self.assertEqual(s.index(_('i'), size),
160                          sublen + size + SUBSTR.index(_('i')))
163     @bigmemtest(size=_2G, memuse=2)
164     def test_isalnum(self, size):  argument
167         s = _('a') * size + SUBSTR
172     @bigmemtest(size=_2G, memuse=2)
173     def test_isalpha(self, size):  argument
176         s = _('a') * size + SUBSTR
181     @bigmemtest(size=_2G, memuse=2)
182     def test_isdigit(self, size):  argument
185         s = _('9') * size + SUBSTR
190     @bigmemtest(size=_2G, memuse=2)
191     def test_islower(self, size):  argument
195         repeats = size // len(chars) + 2
201     @bigmemtest(size=_2G, memuse=2)
202     def test_isspace(self, size):  argument
205         repeats = size // len(whitespace) + 2
211     @bigmemtest(size=_2G, memuse=2)
212     def test_istitle(self, size):  argument
215         s = _('').join([_('A'), _('a') * size, SUBSTR])
222     @bigmemtest(size=_2G, memuse=2)
223     def test_isupper(self, size):  argument
227         repeats = size // len(chars) + 2
233     @bigmemtest(size=_2G, memuse=2)
234     def test_join(self, size):  argument
236         s = _('A') * size
243     @bigmemtest(size=_2G + 10, memuse=1)
244     def test_ljust(self, size):  argument
247         s = SUBSTR.ljust(size)
249         self.assertEqual(len(s), size)
252     @bigmemtest(size=_2G + 10, memuse=2)
253     def test_lower(self, size):  argument
255         s = _('A') * size
257         self.assertEqual(len(s), size)
258         self.assertEqual(s.count(_('a')), size)
260     @bigmemtest(size=_2G + 10, memuse=1)
261     def test_lstrip(self, size):  argument
264         s = SUBSTR.rjust(size)
265         self.assertEqual(len(s), size)
268         s = SUBSTR.ljust(size)
269         self.assertEqual(len(s), size)
275     @bigmemtest(size=_2G + 10, memuse=2)
276     def test_replace(self, size):  argument
279         s = _(' ') * size
281         self.assertEqual(len(s), size)
282         self.assertEqual(s.count(replacement), size)
283         s = s.replace(replacement, _(' '), size - 4)
284         self.assertEqual(len(s), size)
288     @bigmemtest(size=_2G, memuse=2)
289     def test_rfind(self, size):  argument
293         s = _('').join([SUBSTR, _('-') * size, SUBSTR])
294         self.assertEqual(s.rfind(_(' ')), sublen + size + SUBSTR.rfind(_(' ')))
295         self.assertEqual(s.rfind(SUBSTR), sublen + size)
296         self.assertEqual(s.rfind(_(' '), 0, size), SUBSTR.rfind(_(' ')))
297         self.assertEqual(s.rfind(SUBSTR, 0, sublen + size), 0)
298         self.assertEqual(s.rfind(_('i')), sublen + size + SUBSTR.rfind(_('i')))
300         self.assertEqual(s.rfind(_('i'), 0, sublen + size),
304     @bigmemtest(size=_2G, memuse=2)
305     def test_rindex(self, size):  argument
309         s = _('').join([SUBSTR, _('-') * size, SUBSTR])
311                          sublen + size + SUBSTR.rindex(_(' ')))
312         self.assertEqual(s.rindex(SUBSTR), sublen + size)
313         self.assertEqual(s.rindex(_(' '), 0, sublen + size - 1),
315         self.assertEqual(s.rindex(SUBSTR, 0, sublen + size), 0)
317                          sublen + size + SUBSTR.rindex(_('i')))
319         self.assertEqual(s.rindex(_('i'), 0, sublen + size),
323     @bigmemtest(size=_2G + 10, memuse=1)
324     def test_rjust(self, size):  argument
327         s = SUBSTR.ljust(size)
329         self.assertEqual(len(s), size)
332     @bigmemtest(size=_2G + 10, memuse=1)
333     def test_rstrip(self, size):  argument
336         s = SUBSTR.ljust(size)
337         self.assertEqual(len(s), size)
340         s = SUBSTR.rjust(size)
341         self.assertEqual(len(s), size)
350     @bigmemtest(size=_2G, memuse=2.1)
351     def test_split_small(self, size):  argument
355         chunksize = int(size ** 0.5 + 2)
376     @bigmemtest(size=_2G + 5, memuse=ascii_char_size * 2 + pointer_size)
377     def test_split_large(self, size):  argument
379         s = _(' a') * size + _(' ')
381         self.assertEqual(len(l), size)
385         self.assertEqual(len(l), size + 1)
388     @bigmemtest(size=_2G, memuse=2.1)
389     def test_splitlines(self, size):  argument
393         chunksize = int(size ** 0.5 + 2) // 2
402     @bigmemtest(size=_2G, memuse=2)
403     def test_startswith(self, size):  argument
406         s = _('-') * size + SUBSTR
408         self.assertTrue(s.startswith(_('-') * size))
411     @bigmemtest(size=_2G, memuse=1)
412     def test_strip(self, size):  argument
415         s = SUBSTR.rjust(size)
416         self.assertEqual(len(s), size)
419         s = SUBSTR.ljust(size)
420         self.assertEqual(len(s), size)
423     def _test_swapcase(self, size):  argument
427         repeats = size // sublen + 2
434     def _test_title(self, size):  argument
437         s = SUBSTR * (size // len(SUBSTR) + 2)
442     @bigmemtest(size=_2G, memuse=2)
443     def test_translate(self, size):  argument
448         repeats = size // sublen + 2
458     @bigmemtest(size=_2G + 5, memuse=2)
459     def test_upper(self, size):  argument
461         s = _('a') * size
463         self.assertEqual(len(s), size)
464         self.assertEqual(s.count(_('A')), size)
466     @bigmemtest(size=_2G + 20, memuse=1)
467     def test_zfill(self, size):  argument
470         s = SUBSTR.zfill(size)
473         self.assertEqual(len(s), size)
474         self.assertEqual(s.count(_('0')), size - len(SUBSTR))
478     @bigmemtest(size=_1G + 2, memuse=3)
479     def test_concat(self, size):  argument
481         s = _('.') * size
482         self.assertEqual(len(s), size)
484         self.assertEqual(len(s), size * 2)
485         self.assertEqual(s.count(_('.')), size * 2)
489     @bigmemtest(size=_1G + 2, memuse=3)
490     def test_repeat(self, size):  argument
492         s = _('.') * size
493         self.assertEqual(len(s), size)
495         self.assertEqual(len(s), size * 2)
496         self.assertEqual(s.count(_('.')), size * 2)
498     @bigmemtest(size=_2G + 20, memuse=2)
499     def test_slice_and_getitem(self, size):  argument
503         s = SUBSTR * (size // sublen)
532     @bigmemtest(size=_2G, memuse=2)
533     def test_contains(self, size):  argument
536         edge = _('-') * (size // 2)
546     @bigmemtest(size=_2G + 10, memuse=2)
547     def test_compare(self, size):  argument
549         s1 = _('-') * size
550         s2 = _('-') * size
556         s2 = _('.') * size
559     @bigmemtest(size=_2G + 10, memuse=1)
560     def test_hash(self, size):  argument
568         s = _('\x00') * size
571         s = _('\x00') * (size + 1)
580     def basic_encode_test(self, size, enc, c='.', expectedsize=None):  argument
582             expectedsize = size
584             s = c * size
608     @bigmemtest(size=_2G, memuse=ucs4_char_size * 3 + ascii_char_size * 2)
609     def test_capitalize(self, size):  argument
610         self._test_capitalize(size)
612     @bigmemtest(size=_2G, memuse=ucs4_char_size * 3 + ascii_char_size * 2)
613     def test_title(self, size):  argument
614         self._test_title(size)
616     @bigmemtest(size=_2G, memuse=ucs4_char_size * 3 + ascii_char_size * 2)
617     def test_swapcase(self, size):  argument
618         self._test_swapcase(size)
623     @bigmemtest(size=_2G + 2, memuse=ascii_char_size + 1)
624     def test_encode(self, size):  argument
625         return self.basic_encode_test(size, 'utf-8')
627     @bigmemtest(size=_4G // 6 + 2, memuse=ascii_char_size + ucs4_char_size + 1)
628     def test_encode_raw_unicode_escape(self, size):  argument
630             return self.basic_encode_test(size, 'raw_unicode_escape')
634     @bigmemtest(size=_4G // 5 + 70, memuse=ascii_char_size + 8 + 1)
635     def test_encode_utf7(self, size):  argument
637             return self.basic_encode_test(size, 'utf7')
641     @bigmemtest(size=_4G // 4 + 5, memuse=ascii_char_size + ucs4_char_size + 4)
642     def test_encode_utf32(self, size):  argument
644             return self.basic_encode_test(size, 'utf32', expectedsize=4 * size + 4)
648     @bigmemtest(size=_2G - 1, memuse=ascii_char_size + 1)
649     def test_encode_ascii(self, size):  argument
650         return self.basic_encode_test(size, 'ascii', c='A')
654     @bigmemtest(size=_2G + 10, memuse=ascii_char_size * 2 + ucs4_char_size)
655     def test_format(self, size):  argument
656         s = '-' * size
666         size //= 2
667         edge = '-' * size
671         self.assertEqual(len(s), size * 2 + 3)
673         self.assertEqual(s.count('-'), size * 2)
675     @bigmemtest(size=_2G + 10, memuse=ascii_char_size * 2)
676     def test_repr_small(self, size):  argument
677         s = '-' * size
679         self.assertEqual(len(s), size + 2)
682         self.assertEqual(s.count('-'), size)
687         size = size // 5 * 2
688         s = '\x00' * size
690         self.assertEqual(len(s), size * 4 + 2)
693         self.assertEqual(s.count('\\'), size)
694         self.assertEqual(s.count('0'), size * 2)
696     @bigmemtest(size=_2G + 10, memuse=ascii_char_size * 5)
697     def test_repr_large(self, size):  argument
698         s = '\x00' * size
700         self.assertEqual(len(s), size * 4 + 2)
703         self.assertEqual(s.count('\\'), size)
704         self.assertEqual(s.count('0'), size * 2)
711     @bigmemtest(size=_2G // 5 + 1, memuse=ucs2_char_size +
713     def test_unicode_repr(self, size):  argument
717         s = char * size
721                 self.assertEqual(len(r), 2 + (len(f(char)) - 2) * size)
727     @bigmemtest(size=_2G // 5 + 1, memuse=ucs4_char_size * 2 + ascii_char_size * 10)
728     def test_unicode_repr_wide(self, size):  argument
730         s = char * size
734                 self.assertEqual(len(r), 2 + (len(f(char)) - 2) * size)
744     @bigmemtest(size=_2G, memuse=ascii_char_size * 2 + ucs4_char_size)
745     def test_translate(self, size):  argument
754         repeats = size // sublen + 2
770     @bigmemtest(size=_2G + 2, memuse=1 + ascii_char_size)
771     def test_decode(self, size):  argument
772         s = self.from_latin1('.') * size
773         self.assertEqual(len(s.decode('utf-8')), size)
775     @bigmemtest(size=_2G, memuse=2)
776     def test_capitalize(self, size):  argument
777         self._test_capitalize(size)
779     @bigmemtest(size=_2G, memuse=2)
780     def test_title(self, size):  argument
781         self._test_title(size)
783     @bigmemtest(size=_2G, memuse=2)
784     def test_swapcase(self, size):  argument
785         self._test_swapcase(size)
793     @bigmemtest(size=_2G + 2, memuse=1 + ascii_char_size)
794     def test_decode(self, size):  argument
795         s = self.from_latin1('.') * size
796         self.assertEqual(len(s.decode('utf-8')), size)
798     @bigmemtest(size=_2G, memuse=2)
799     def test_capitalize(self, size):  argument
800         self._test_capitalize(size)
802     @bigmemtest(size=_2G, memuse=2)
803     def test_title(self, size):  argument
804         self._test_title(size)
806     @bigmemtest(size=_2G, memuse=2)
807     def test_swapcase(self, size):  argument
808         self._test_swapcase(size)
824     @bigmemtest(size=_2G + 2, memuse=pointer_size * 2)
825     def test_compare(self, size):  argument
826         t1 = ('',) * size
827         t2 = ('',) * size
830         t2 = ('',) * (size + 1)
833         t2 = (1,) * size
841     def basic_concat_test(self, size):  argument
842         t = ((),) * size
843         self.assertEqual(len(t), size)
845         self.assertEqual(len(t), size * 2)
847     @bigmemtest(size=_2G // 2 + 2, memuse=pointer_size * 3)
848     def test_concat_small(self, size):  argument
849         return self.basic_concat_test(size)
851     @bigmemtest(size=_2G + 2, memuse=pointer_size * 3)
852     def test_concat_large(self, size):  argument
853         return self.basic_concat_test(size)
855     @bigmemtest(size=_2G // 5 + 10, memuse=pointer_size * 5)
856     def test_contains(self, size):  argument
857         t = (1, 2, 3, 4, 5) * size
858         self.assertEqual(len(t), size * 5)
863     @bigmemtest(size=_2G + 10, memuse=pointer_size)
864     def test_hash(self, size):  argument
865         t1 = (0,) * size
868         t2 = (0,) * (size + 1)
871     @bigmemtest(size=_2G + 10, memuse=pointer_size)
872     def test_index_and_slice(self, size):  argument
873         t = (None,) * size
874         self.assertEqual(len(t), size)
877         self.assertEqual(t[size - 1], None)
878         self.assertRaises(IndexError, operator.getitem, t, size)
883         self.assertEqual(t[size - 5:], (None,) * 5)
884         self.assertEqual(t[size - 5:size], (None,) * 5)
885         self.assertEqual(t[size - 6:size - 2], (None,) * 4)
886         self.assertEqual(t[size:size], ())
887         self.assertEqual(t[size:size+5], ())
890     def basic_test_repeat(self, size):  argument
891         t = ('',) * size
892         self.assertEqual(len(t), size)
894         self.assertEqual(len(t), size * 2)
896     @bigmemtest(size=_2G // 2 + 2, memuse=pointer_size * 3)
897     def test_repeat_small(self, size):  argument
898         return self.basic_test_repeat(size)
900     @bigmemtest(size=_2G + 2, memuse=pointer_size * 3)
901     def test_repeat_large(self, size):  argument
902         return self.basic_test_repeat(size)
904     @bigmemtest(size=_1G - 1, memuse=12)
905     def test_repeat_large_2(self, size):  argument
906         return self.basic_test_repeat(size)
908     @bigmemtest(size=_1G - 1, memuse=pointer_size * 2)
909     def test_from_2G_generator(self, size):  argument
911             t = tuple(iter([42]*size))
915             self.assertEqual(len(t), size)
919     @bigmemtest(size=_1G - 25, memuse=pointer_size * 2)
920     def test_from_almost_2G_generator(self, size):  argument
922             t = tuple(iter([42]*size))
926             self.assertEqual(len(t), size)
931     def basic_test_repr(self, size):  argument
932         t = (False,) * size
935         self.assertEqual(len(s), size * 7)
939     @bigmemtest(size=_2G // 7 + 2, memuse=pointer_size + ascii_char_size * 7)
940     def test_repr_small(self, size):  argument
941         return self.basic_test_repr(size)
943     @bigmemtest(size=_2G + 2, memuse=pointer_size + ascii_char_size * 7)
944     def test_repr_large(self, size):  argument
945         return self.basic_test_repr(size)
954     @bigmemtest(size=_2G + 2, memuse=pointer_size * 2)
955     def test_compare(self, size):  argument
956         l1 = [''] * size
957         l2 = [''] * size
960         l2 = [''] * (size + 1)
963         l2 = [2] * size
971     def basic_test_concat(self, size):  argument
972         l = [[]] * size
973         self.assertEqual(len(l), size)
975         self.assertEqual(len(l), size * 2)
977     @bigmemtest(size=_2G // 2 + 2, memuse=pointer_size * 3)
978     def test_concat_small(self, size):  argument
979         return self.basic_test_concat(size)
981     @bigmemtest(size=_2G + 2, memuse=pointer_size * 3)
982     def test_concat_large(self, size):  argument
983         return self.basic_test_concat(size)
987     def basic_test_inplace_concat(self, size):  argument
988         l = [sys.stdout] * size
990         self.assertEqual(len(l), size * 2)
992         self.assertTrue(l[size - 1] is l[size + 1])
994     @bigmemtest(size=_2G // 2 + 2, memuse=pointer_size * 2 * 9/8)
995     def test_inplace_concat_small(self, size):  argument
996         return self.basic_test_inplace_concat(size)
998     @bigmemtest(size=_2G + 2, memuse=pointer_size * 2 * 9/8)
999     def test_inplace_concat_large(self, size):  argument
1000         return self.basic_test_inplace_concat(size)
1002     @bigmemtest(size=_2G // 5 + 10, memuse=pointer_size * 5)
1003     def test_contains(self, size):  argument
1004         l = [1, 2, 3, 4, 5] * size
1005         self.assertEqual(len(l), size * 5)
1010     @bigmemtest(size=_2G + 10, memuse=pointer_size)
1011     def test_hash(self, size):  argument
1012         l = [0] * size
1015     @bigmemtest(size=_2G + 10, memuse=pointer_size)
1016     def test_index_and_slice(self, size):  argument
1017         l = [None] * size
1018         self.assertEqual(len(l), size)
1021         self.assertEqual(l[size - 1], None)
1022         self.assertRaises(IndexError, operator.getitem, l, size)
1027         self.assertEqual(l[size - 5:], [None] * 5)
1028         self.assertEqual(l[size - 5:size], [None] * 5)
1029         self.assertEqual(l[size - 6:size - 2], [None] * 4)
1030         self.assertEqual(l[size:size], [])
1031         self.assertEqual(l[size:size+5], [])
1033         l[size - 2] = 5
1034         self.assertEqual(len(l), size)
1037         self.assertRaises(IndexError, operator.setitem, l, size, 6)
1038         self.assertEqual(len(l), size)
1040         l[size - 7:] = [1, 2, 3, 4, 5]
1041         size -= 2
1042         self.assertEqual(len(l), size)
1046         size -= 2
1047         self.assertEqual(len(l), size)
1050         del l[size - 1]
1051         size -= 1
1052         self.assertEqual(len(l), size)
1056         size -= 2
1057         self.assertEqual(len(l), size)
1061         size -= 1
1062         self.assertEqual(len(l), size)
1066         size -= 2
1067         self.assertEqual(len(l), size)
1071     def basic_test_repeat(self, size):  argument
1072         l = [] * size
1074         l = [''] * size
1075         self.assertEqual(len(l), size)
1077         self.assertEqual(len(l), size * 2)
1079     @bigmemtest(size=_2G // 2 + 2, memuse=pointer_size * 3)
1080     def test_repeat_small(self, size):  argument
1081         return self.basic_test_repeat(size)
1083     @bigmemtest(size=_2G + 2, memuse=pointer_size * 3)
1084     def test_repeat_large(self, size):  argument
1085         return self.basic_test_repeat(size)
1089     def basic_test_inplace_repeat(self, size):  argument
1091         l *= size
1092         self.assertEqual(len(l), size)
1096         l = [''] * size
1098         self.assertEqual(len(l), size * 2)
1099         self.assertTrue(l[size - 1] is l[-1])
1101     @bigmemtest(size=_2G // 2 + 2, memuse=pointer_size * 2 * 9/8)
1102     def test_inplace_repeat_small(self, size):  argument
1103         return self.basic_test_inplace_repeat(size)
1105     @bigmemtest(size=_2G + 2, memuse=pointer_size * 2 * 9/8)
1106     def test_inplace_repeat_large(self, size):  argument
1107         return self.basic_test_inplace_repeat(size)
1109     def basic_test_repr(self, size):  argument
1110         l = [False] * size
1113         self.assertEqual(len(s), size * 7)
1116         self.assertEqual(s.count('F'), size)
1118     @bigmemtest(size=_2G // 7 + 2, memuse=pointer_size + ascii_char_size * 7)
1119     def test_repr_small(self, size):  argument
1120         return self.basic_test_repr(size)
1122     @bigmemtest(size=_2G + 2, memuse=pointer_size + ascii_char_size * 7)
1123     def test_repr_large(self, size):  argument
1124         return self.basic_test_repr(size)
1128     @bigmemtest(size=_2G, memuse=pointer_size * 9/8)
1129     def test_append(self, size):  argument
1130         l = [object()] * size
1132         self.assertEqual(len(l), size+1)
1136     @bigmemtest(size=_2G // 5 + 2, memuse=pointer_size * 5)
1137     def test_count(self, size):  argument
1138         l = [1, 2, 3, 4, 5] * size
1139         self.assertEqual(l.count(1), size)
1144     def basic_test_extend(self, size):  argument
1145         l = [object] * size
1147         self.assertEqual(len(l), size * 2)
1149         self.assertTrue(l[size - 1] is l[size + 1])
1151     @bigmemtest(size=_2G // 2 + 2, memuse=pointer_size * 2 * 9/8)
1152     def test_extend_small(self, size):  argument
1153         return self.basic_test_extend(size)
1155     @bigmemtest(size=_2G + 2, memuse=pointer_size * 2 * 9/8)
1156     def test_extend_large(self, size):  argument
1157         return self.basic_test_extend(size)
1159     @bigmemtest(size=_2G // 5 + 2, memuse=pointer_size * 5)
1160     def test_index(self, size):  argument
1161         l = [1, 2, 3, 4, 5] * size
1162         size *= 5
1164         self.assertEqual(l.index(5, size - 5), size - 1)
1165         self.assertEqual(l.index(5, size - 5, size), size - 1)
1166         self.assertRaises(ValueError, l.index, 1, size - 4, size)
1170     @bigmemtest(size=_2G + 10, memuse=pointer_size * 9/8)
1171     def test_insert(self, size):  argument
1172         l = [1.0] * size
1173         l.insert(size - 1, "A")
1174         size += 1
1175         self.assertEqual(len(l), size)
1178         l.insert(size + 1, "B")
1179         size += 1
1180         self.assertEqual(len(l), size)
1184         size += 1
1185         self.assertEqual(len(l), size)
1187         self.assertEqual(l[size - 3:], ["A", 1.0, "B"])
1189     @bigmemtest(size=_2G // 5 + 4, memuse=pointer_size * 5)
1190     def test_pop(self, size):  argument
1191         l = ["a", "b", "c", "d", "e"] * size
1192         size *= 5
1193         self.assertEqual(len(l), size)
1196         size -= 1
1197         self.assertEqual(len(l), size)
1202         size -= 1
1203         self.assertEqual(len(l), size)
1207         item = l.pop(size - 2)
1208         size -= 1
1209         self.assertEqual(len(l), size)
1213     @bigmemtest(size=_2G + 10, memuse=pointer_size)
1214     def test_remove(self, size):  argument
1215         l = [10] * size
1216         self.assertEqual(len(l), size)
1219         size -= 1
1220         self.assertEqual(len(l), size)
1225         size += 1
1226         self.assertEqual(len(l), size)
1229         size -= 1
1230         self.assertEqual(len(l), size)
1233     @bigmemtest(size=_2G // 5 + 2, memuse=pointer_size * 5)
1234     def test_reverse(self, size):  argument
1235         l = [1, 2, 3, 4, 5] * size
1237         self.assertEqual(len(l), size * 5)
1241     @bigmemtest(size=_2G // 5 + 2, memuse=pointer_size * 5 * 1.5)
1242     def test_sort(self, size):  argument
1243         l = [1, 2, 3, 4, 5] * size
1245         self.assertEqual(len(l), size * 5)
1246         self.assertEqual(l.count(1), size)