Mercurial > cpython-lru_cache-weakref

annotate Lib/test/test_sort.py @ 78069:a8aa77458e12 3.2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add c_size_t and c_ssize_t to the ctypes summary table.
author Antoine Pitrou <solipsis@pitrou.net>
date Thu, 12 Jul 2012 20:31:50 +0200
parents fefb7d355361
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
47201
9c930a32cebb #2621 rename test.test_support to test.support
Benjamin Peterson <benjamin@python.org>
parents: 45061
diff changeset
1 from test import support
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
2 import random
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
3 import sys
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
4 import unittest
71550
fefb7d355361 Remove duplicates of cmp_to_key (#12542, reviewed by Raymond Hettinger)
Éric Araujo <merwok@netwok.org>
parents: 69836
diff changeset
5 from functools import cmp_to_key
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
6
47201
9c930a32cebb #2621 rename test.test_support to test.support
Benjamin Peterson <benjamin@python.org>
parents: 45061
diff changeset
7 verbose = support.verbose
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
8 nerrors = 0
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
9
45061
b9ee31a26f38 Issue #1771: Remove cmp parameter from list.sort() and builtin.sorted().
Raymond Hettinger <python@rcn.com>
parents: 41717
diff changeset
10
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
11 def check(tag, expected, raw, compare=None):
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
12 global nerrors
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
13
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
14 if verbose:
40775
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
15 print(" checking", tag)
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
16
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
17 orig = raw[:] # save input in case of error
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
18 if compare:
71550
fefb7d355361 Remove duplicates of cmp_to_key (#12542, reviewed by Raymond Hettinger)
Éric Araujo <merwok@netwok.org>
parents: 69836
diff changeset
19 raw.sort(key=cmp_to_key(compare))
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
20 else:
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
21 raw.sort()
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
22
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
23 if len(expected) != len(raw):
40775
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
24 print("error in", tag)
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
25 print("length mismatch;", len(expected), len(raw))
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
26 print(expected)
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
27 print(orig)
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
28 print(raw)
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
29 nerrors += 1
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
30 return
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
31
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
32 for i, good in enumerate(expected):
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
33 maybe = raw[i]
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
34 if good is not maybe:
40775
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
35 print("error in", tag)
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
36 print("out of order at index", i, good, maybe)
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
37 print(expected)
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
38 print(orig)
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
39 print(raw)
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
40 nerrors += 1
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
41 return
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
42
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
43 class TestBase(unittest.TestCase):
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
44 def testStressfully(self):
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
45 # Try a variety of sizes at and around powers of 2, and at powers of 10.
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
46 sizes = [0]
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
47 for power in range(1, 10):
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
48 n = 2 ** power
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
49 sizes.extend(range(n-1, n+2))
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
50 sizes.extend([10, 100, 1000])
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
51
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
52 class Complains(object):
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
53 maybe_complain = True
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
54
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
55 def __init__(self, i):
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
56 self.i = i
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
57
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
58 def __lt__(self, other):
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
59 if Complains.maybe_complain and random.random() < 0.001:
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
60 if verbose:
40775
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
61 print(" complaining at", self, other)
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
62 raise RuntimeError
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
63 return self.i < other.i
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
64
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
65 def __repr__(self):
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
66 return "Complains(%d)" % self.i
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
67
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
68 class Stable(object):
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
69 def __init__(self, key, i):
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
70 self.key = key
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
71 self.index = i
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
72
39644
13d5e5f0e993 Restructure comparison dramatically. There is no longer a default
Guido van Rossum <guido@python.org>
parents: 35937
diff changeset
73 def __lt__(self, other):
13d5e5f0e993 Restructure comparison dramatically. There is no longer a default
Guido van Rossum <guido@python.org>
parents: 35937
diff changeset
74 return self.key < other.key
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
75
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
76 def __repr__(self):
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
77 return "Stable(%d, %d)" % (self.key, self.index)
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
78
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
79 for n in sizes:
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
80 x = list(range(n))
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
81 if verbose:
40775
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
82 print("Testing size", n)
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
83
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
84 s = x[:]
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
85 check("identity", x, s)
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
86
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
87 s = x[:]
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
88 s.reverse()
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
89 check("reversed", x, s)
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
90
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
91 s = x[:]
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
92 random.shuffle(s)
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
93 check("random permutation", x, s)
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
94
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
95 y = x[:]
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
96 y.reverse()
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
97 s = x[:]
51122
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
98 check("reversed via function", y, s, lambda a, b: (b>a)-(b<a))
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
99
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
100 if verbose:
40775
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
101 print(" Checking against an insane comparison function.")
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
102 print(" If the implementation isn't careful, this may segfault.")
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
103 s = x[:]
71550
fefb7d355361 Remove duplicates of cmp_to_key (#12542, reviewed by Raymond Hettinger)
Éric Araujo <merwok@netwok.org>
parents: 69836
diff changeset
104 s.sort(key=cmp_to_key(lambda a, b: int(random.random() * 3) - 1))
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
105 check("an insane function left some permutation", x, s)
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
106
69836
52fb7dc721ed #11335: Fix memory leak after key function failure in sort
Daniel Stutzbach <daniel.stutzbach@google.com>
parents: 51122
diff changeset
107 if len(x) >= 2:
52fb7dc721ed #11335: Fix memory leak after key function failure in sort
Daniel Stutzbach <daniel.stutzbach@google.com>
parents: 51122
diff changeset
108 def bad_key(x):
52fb7dc721ed #11335: Fix memory leak after key function failure in sort
Daniel Stutzbach <daniel.stutzbach@google.com>
parents: 51122
diff changeset
109 raise RuntimeError
52fb7dc721ed #11335: Fix memory leak after key function failure in sort
Daniel Stutzbach <daniel.stutzbach@google.com>
parents: 51122
diff changeset
110 s = x[:]
52fb7dc721ed #11335: Fix memory leak after key function failure in sort
Daniel Stutzbach <daniel.stutzbach@google.com>
parents: 51122
diff changeset
111 self.assertRaises(RuntimeError, s.sort, key=bad_key)
52fb7dc721ed #11335: Fix memory leak after key function failure in sort
Daniel Stutzbach <daniel.stutzbach@google.com>
parents: 51122
diff changeset
112
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
113 x = [Complains(i) for i in x]
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
114 s = x[:]
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
115 random.shuffle(s)
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
116 Complains.maybe_complain = True
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
117 it_complained = False
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
118 try:
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
119 s.sort()
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
120 except RuntimeError:
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
121 it_complained = True
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
122 if it_complained:
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
123 Complains.maybe_complain = False
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
124 check("exception during sort left some permutation", x, s)
24457
27825d268317 New test for sorting sanity. Note that this will fail in earlier Pythons,
Tim Peters <tim.peters@gmail.com>
parents:
diff changeset
125
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
126 s = [Stable(random.randrange(10), i) for i in range(n)]
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
127 augmented = [(e, e.index) for e in s]
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
128 augmented.sort() # forced stable because ties broken by index
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
129 x = [e for e, i in augmented] # a stable sort of s
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
130 check("stability", x, s)
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
131
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
132 #==============================================================================
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
133
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
134 class TestBugs(unittest.TestCase):
26161
dd10d97d329a SF patch 637176: list.sort crasher
Tim Peters <tim.peters@gmail.com>
parents: 24514
diff changeset
135
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
136 def test_bug453523(self):
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
137 # bug 453523 -- list.sort() crasher.
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
138 # If this fails, the most likely outcome is a core dump.
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
139 # Mutations during a list sort should raise a ValueError.
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
140
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
141 class C:
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
142 def __lt__(self, other):
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
143 if L and random.random() < 0.75:
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
144 L.pop()
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
145 else:
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
146 L.append(3)
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
147 return random.random() < 0.5
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
148
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
149 L = [C() for i in range(50)]
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
150 self.assertRaises(ValueError, L.sort)
26161
dd10d97d329a SF patch 637176: list.sort crasher
Tim Peters <tim.peters@gmail.com>
parents: 24514
diff changeset
151
32858
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
152 def test_undetected_mutation(self):
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
153 # Python 2.4a1 did not always detect mutation
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
154 memorywaster = []
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
155 for i in range(20):
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
156 def mutating_cmp(x, y):
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
157 L.append(3)
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
158 L.pop()
51122
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
159 return (x > y) - (x < y)
32858
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
160 L = [1,2]
71550
fefb7d355361 Remove duplicates of cmp_to_key (#12542, reviewed by Raymond Hettinger)
Éric Araujo <merwok@netwok.org>
parents: 69836
diff changeset
161 self.assertRaises(ValueError, L.sort, key=cmp_to_key(mutating_cmp))
32858
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
162 def mutating_cmp(x, y):
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
163 L.append(3)
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
164 del L[:]
51122
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
165 return (x > y) - (x < y)
71550
fefb7d355361 Remove duplicates of cmp_to_key (#12542, reviewed by Raymond Hettinger)
Éric Araujo <merwok@netwok.org>
parents: 69836
diff changeset
166 self.assertRaises(ValueError, L.sort, key=cmp_to_key(mutating_cmp))
32858
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
167 memorywaster = [memorywaster]
fa0526c30da8 * drop the unreasonable list invariant that ob_item should never come back
Armin Rigo <arigo@tunes.org>
parents: 31389
diff changeset
168
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
169 #==============================================================================
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
170
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
171 class TestDecorateSortUndecorate(unittest.TestCase):
26161
dd10d97d329a SF patch 637176: list.sort crasher
Tim Peters <tim.peters@gmail.com>
parents: 24514
diff changeset
172
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
173 def test_decorated(self):
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
174 data = 'The quick Brown fox Jumped over The lazy Dog'.split()
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
175 copy = data[:]
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
176 random.shuffle(data)
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
177 data.sort(key=str.lower)
51122
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
178 def my_cmp(x, y):
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
179 xlower, ylower = x.lower(), y.lower()
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
180 return (xlower > ylower) - (xlower < ylower)
71550
fefb7d355361 Remove duplicates of cmp_to_key (#12542, reviewed by Raymond Hettinger)
Éric Araujo <merwok@netwok.org>
parents: 69836
diff changeset
181 copy.sort(key=cmp_to_key(my_cmp))
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
182
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
183 def test_baddecorator(self):
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
184 data = 'The quick Brown fox Jumped over The lazy Dog'.split()
45061
b9ee31a26f38 Issue #1771: Remove cmp parameter from list.sort() and builtin.sorted().
Raymond Hettinger <python@rcn.com>
parents: 41717
diff changeset
185 self.assertRaises(TypeError, data.sort, key=lambda x,y: 0)
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
186
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
187 def test_stability(self):
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
188 data = [(random.randrange(100), i) for i in range(200)]
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
189 copy = data[:]
41717
9ad84070b22d Merged revisions 55328-55341 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 41642
diff changeset
190 data.sort(key=lambda t: t[0]) # sort on the random first field
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
191 copy.sort() # sort using both fields
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
192 self.assertEqual(data, copy) # should get the same result
26161
dd10d97d329a SF patch 637176: list.sort crasher
Tim Peters <tim.peters@gmail.com>
parents: 24514
diff changeset
193
31041
6f01700c1808 Make sure the list.sort's decorate step unwinds itself before returning
Raymond Hettinger <python@rcn.com>
parents: 30929
diff changeset
194 def test_key_with_exception(self):
6f01700c1808 Make sure the list.sort's decorate step unwinds itself before returning
Raymond Hettinger <python@rcn.com>
parents: 30929
diff changeset
195 # Verify that the wrapper has been removed
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
196 data = list(range(-2, 2))
31041
6f01700c1808 Make sure the list.sort's decorate step unwinds itself before returning
Raymond Hettinger <python@rcn.com>
parents: 30929
diff changeset
197 dup = data[:]
45061
b9ee31a26f38 Issue #1771: Remove cmp parameter from list.sort() and builtin.sorted().
Raymond Hettinger <python@rcn.com>
parents: 41717
diff changeset
198 self.assertRaises(ZeroDivisionError, data.sort, key=lambda x: 1/x)
31041
6f01700c1808 Make sure the list.sort's decorate step unwinds itself before returning
Raymond Hettinger <python@rcn.com>
parents: 30929
diff changeset
199 self.assertEqual(data, dup)
6f01700c1808 Make sure the list.sort's decorate step unwinds itself before returning
Raymond Hettinger <python@rcn.com>
parents: 30929
diff changeset
200
31093
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
201 def test_key_with_mutation(self):
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
202 data = list(range(10))
31093
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
203 def k(x):
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
204 del data[:]
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
205 data[:] = range(20)
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
206 return x
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
207 self.assertRaises(ValueError, data.sort, key=k)
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
208
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
209 def test_key_with_mutating_del(self):
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
210 data = list(range(10))
31093
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
211 class SortKiller(object):
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
212 def __init__(self, x):
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
213 pass
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
214 def __del__(self):
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
215 del data[:]
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
216 data[:] = range(20)
39644
13d5e5f0e993 Restructure comparison dramatically. There is no longer a default
Guido van Rossum <guido@python.org>
parents: 35937
diff changeset
217 def __lt__(self, other):
13d5e5f0e993 Restructure comparison dramatically. There is no longer a default
Guido van Rossum <guido@python.org>
parents: 35937
diff changeset
218 return id(self) < id(other)
31093
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
219 self.assertRaises(ValueError, data.sort, key=SortKiller)
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
220
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
221 def test_key_with_mutating_del_and_exception(self):
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
222 data = list(range(10))
31093
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
223 ## dup = data[:]
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
224 class SortKiller(object):
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
225 def __init__(self, x):
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
226 if x > 2:
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
227 raise RuntimeError
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
228 def __del__(self):
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
229 del data[:]
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
230 data[:] = list(range(20))
31093
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
231 self.assertRaises(RuntimeError, data.sort, key=SortKiller)
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
232 ## major honking subtlety: we *can't* do:
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
233 ##
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
234 ## self.assertEqual(data, dup)
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
235 ##
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
236 ## because there is a reference to a SortKiller in the
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
237 ## traceback and by the time it dies we're outside the call to
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
238 ## .sort() and so the list protection gimmicks are out of
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
239 ## date (this cost some brain cells to figure out...).
f2e7646f7763 Fixes and tests for various "holding pointers when arbitrary Python code
Michael W. Hudson <mwh@python.net>
parents: 31041
diff changeset
240
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
241 def test_reverse(self):
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
242 data = list(range(100))
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
243 random.shuffle(data)
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
244 data.sort(reverse=True)
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
245 self.assertEqual(data, list(range(99,-1,-1)))
27036
41f7726e3e51 Allow list sort's comparison function to explicitly be None. See SF patch
Skip Montanaro <skip@pobox.com>
parents: 26161
diff changeset
246
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
247 def test_reverse_stability(self):
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
248 data = [(random.randrange(100), i) for i in range(200)]
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
249 copy1 = data[:]
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
250 copy2 = data[:]
51122
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
251 def my_cmp(x, y):
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
252 x0, y0 = x[0], y[0]
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
253 return (x0 > y0) - (x0 < y0)
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
254 def my_cmp_reversed(x, y):
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
255 x0, y0 = x[0], y[0]
adbd77a90bde Merged revisions 69025 via svnmerge from
Mark Dickinson <dickinsm@gmail.com>
parents: 47201
diff changeset
256 return (y0 > x0) - (y0 < x0)
71550
fefb7d355361 Remove duplicates of cmp_to_key (#12542, reviewed by Raymond Hettinger)
Éric Araujo <merwok@netwok.org>
parents: 69836
diff changeset
257 data.sort(key=cmp_to_key(my_cmp), reverse=True)
fefb7d355361 Remove duplicates of cmp_to_key (#12542, reviewed by Raymond Hettinger)
Éric Araujo <merwok@netwok.org>
parents: 69836
diff changeset
258 copy1.sort(key=cmp_to_key(my_cmp_reversed))
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
259 self.assertEqual(data, copy1)
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
260 copy2.sort(key=lambda x: x[0], reverse=True)
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
261 self.assertEqual(data, copy2)
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
262
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
263 #==============================================================================
27036
41f7726e3e51 Allow list sort's comparison function to explicitly be None. See SF patch
Skip Montanaro <skip@pobox.com>
parents: 26161
diff changeset
264
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
265 def test_main(verbose=None):
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
266 test_classes = (
35937
e6d31cbf2ed3 move test into a unittest.TestCase, no functional changes
Neal Norwitz <nnorwitz@gmail.com>
parents: 32858
diff changeset
267 TestBase,
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
268 TestDecorateSortUndecorate,
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
269 TestBugs,
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
270 )
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
271
47201
9c930a32cebb #2621 rename test.test_support to test.support
Benjamin Peterson <benjamin@python.org>
parents: 45061
diff changeset
272 support.run_unittest(*test_classes)
27036
41f7726e3e51 Allow list sort's comparison function to explicitly be None. See SF patch
Skip Montanaro <skip@pobox.com>
parents: 26161
diff changeset
273
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
274 # verify reference counting
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
275 if verbose and hasattr(sys, "gettotalrefcount"):
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
276 import gc
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
277 counts = [None] * 5
41642
a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from
Guido van Rossum <guido@python.org>
parents: 40775
diff changeset
278 for i in range(len(counts)):
47201
9c930a32cebb #2621 rename test.test_support to test.support
Benjamin Peterson <benjamin@python.org>
parents: 45061
diff changeset
279 support.run_unittest(*test_classes)
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
280 gc.collect()
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
281 counts[i] = sys.gettotalrefcount()
40775
4cdf21a0dbbc Fix most trivially-findable print statements.
Guido van Rossum <guido@python.org>
parents: 39644
diff changeset
282 print(counts)
30697
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
283
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
284 if __name__ == "__main__":
1345c23a0591 * list.sort() now supports three keyword arguments: cmp, key, and reverse.
Raymond Hettinger <python@rcn.com>
parents: 27036
diff changeset
285 test_main(verbose=True)