Issue #1717, stage 2: remove uses of tp_compare in Modules and most
Objects.
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 9cedf44..8d43d7a 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -3885,7 +3885,7 @@
# Testing method-wrapper objects...
# <type 'method-wrapper'> did not support any reflection before 2.5
- return # XXX should methods really support __eq__?
+ # XXX should methods really support __eq__?
l = []
self.assertEqual(l.__add__, l.__add__)
diff --git a/Lib/test/test_funcattrs.py b/Lib/test/test_funcattrs.py
index 5e9f7d3..7aab8b8 100644
--- a/Lib/test/test_funcattrs.py
+++ b/Lib/test/test_funcattrs.py
@@ -224,10 +224,41 @@
del self.b.__doc__
self.assertEqual(self.b.__doc__, None)
+def cell(value):
+ """Create a cell containing the given value."""
+ def f():
+ print(a)
+ a = value
+ return f.__closure__[0]
+
+def empty_cell(empty=True):
+ """Create an empty cell."""
+ def f():
+ print(a)
+ # the intent of the following line is simply "if False:"; it's
+ # spelt this way to avoid the danger that a future optimization
+ # might simply remove an "if False:" code block.
+ if not empty:
+ a = 1729
+ return f.__closure__[0]
+
+class CellTest(unittest.TestCase):
+ def test_comparison(self):
+ # These tests are here simply to exercise the comparison code;
+ # their presence should not be interpreted as providing any
+ # guarantees about the semantics (or even existence) of cell
+ # comparisons in future versions of CPython.
+ self.assert_(cell(2) < cell(3))
+ self.assert_(empty_cell() < cell('saturday'))
+ self.assert_(empty_cell() == empty_cell())
+ self.assert_(cell(-36) == cell(-36.0))
+ self.assert_(cell(True) > empty_cell())
+
+
def test_main():
support.run_unittest(FunctionPropertiesTest, ImplicitReferencesTest,
ArbitraryFunctionAttrTest, FunctionDictsTest,
- FunctionDocstringTest)
+ FunctionDocstringTest, CellTest)
if __name__ == "__main__":
test_main()
diff --git a/Lib/test/test_parser.py b/Lib/test/test_parser.py
index 2f1310b..86ede3e 100644
--- a/Lib/test/test_parser.py
+++ b/Lib/test/test_parser.py
@@ -2,6 +2,7 @@
import os
import unittest
import sys
+import operator
from test import support
#
@@ -496,12 +497,81 @@
file=sys.stderr)
self.assertRaises(MemoryError, parser.expr, e)
+class STObjectTestCase(unittest.TestCase):
+ """Test operations on ST objects themselves"""
+
+ def test_comparisons(self):
+ # ST objects should support order and equality comparisons
+ st1 = parser.expr('2 + 3')
+ st2 = parser.suite('x = 2; y = x + 3')
+ st3 = parser.expr('list(x**3 for x in range(20))')
+ st1_copy = parser.expr('2 + 3')
+ st2_copy = parser.suite('x = 2; y = x + 3')
+ st3_copy = parser.expr('list(x**3 for x in range(20))')
+
+ # exercise fast path for object identity
+ self.assertEquals(st1 == st1, True)
+ self.assertEquals(st2 == st2, True)
+ self.assertEquals(st3 == st3, True)
+ # slow path equality
+ self.assertEqual(st1, st1_copy)
+ self.assertEqual(st2, st2_copy)
+ self.assertEqual(st3, st3_copy)
+ self.assertEquals(st1 == st2, False)
+ self.assertEquals(st1 == st3, False)
+ self.assertEquals(st2 == st3, False)
+ self.assertEquals(st1 != st1, False)
+ self.assertEquals(st2 != st2, False)
+ self.assertEquals(st3 != st3, False)
+ self.assertEquals(st1 != st1_copy, False)
+ self.assertEquals(st2 != st2_copy, False)
+ self.assertEquals(st3 != st3_copy, False)
+ self.assertEquals(st2 != st1, True)
+ self.assertEquals(st1 != st3, True)
+ self.assertEquals(st3 != st2, True)
+ # we don't particularly care what the ordering is; just that
+ # it's usable and self-consistent
+ self.assertEquals(st1 < st2, not (st2 <= st1))
+ self.assertEquals(st1 < st3, not (st3 <= st1))
+ self.assertEquals(st2 < st3, not (st3 <= st2))
+ self.assertEquals(st1 < st2, st2 > st1)
+ self.assertEquals(st1 < st3, st3 > st1)
+ self.assertEquals(st2 < st3, st3 > st2)
+ self.assertEquals(st1 <= st2, st2 >= st1)
+ self.assertEquals(st3 <= st1, st1 >= st3)
+ self.assertEquals(st2 <= st3, st3 >= st2)
+ # transitivity
+ bottom = min(st1, st2, st3)
+ top = max(st1, st2, st3)
+ mid = sorted([st1, st2, st3])[1]
+ self.assert_(bottom < mid)
+ self.assert_(bottom < top)
+ self.assert_(mid < top)
+ self.assert_(bottom <= mid)
+ self.assert_(bottom <= top)
+ self.assert_(mid <= top)
+ self.assert_(bottom <= bottom)
+ self.assert_(mid <= mid)
+ self.assert_(top <= top)
+ # interaction with other types
+ self.assertEquals(st1 == 1588.602459, False)
+ self.assertEquals('spanish armada' != st2, True)
+ self.assertRaises(TypeError, operator.ge, st3, None)
+ self.assertRaises(TypeError, operator.le, False, st1)
+ self.assertRaises(TypeError, operator.lt, st1, 1815)
+ self.assertRaises(TypeError, operator.gt, b'waterloo', st2)
+
+
+ # XXX tests for pickling and unpickling of ST objects should go here
+
+
def test_main():
support.run_unittest(
RoundtripLegalSyntaxTestCase,
IllegalSyntaxTestCase,
CompileTestCase,
ParserStackLimitTestCase,
+ STObjectTestCase,
)