Merge lp:~gz/brz/py3_static_tuple_mismatched_types into lp:brz

[Martin Packman]

Make StaticTuple tests pass on Python 3

Fix remaining StaticTuple test failures on Python 3.

All related to the change in semantics of lt/gt comparisons with mismatched types. I'm hoping we don't actually have core logic trying to sort tuples with different contents anywhere.

[Jelmer Vernooij (jelmer)]

review: Approve

=== modified file 'breezy/_static_tuple_c.c'
--- breezy/_static_tuple_c.c	2017-06-25 23:37:57 +0000
+++ breezy/_static_tuple_c.c	2017-06-27 01:23:29 +0000
@@ -428,14 +428,22 @@
     } else if (w == Py_None) {
         // None is always less than the object
         switch (op) {
-        case Py_NE:case Py_GT:case Py_GE:
+        case Py_NE:
+#if PY_MAJOR_VERSION >= 3
+#else
+        case Py_GT:case Py_GE:
+#endif
             Py_INCREF(Py_True);
             return Py_True;
-        case Py_EQ:case Py_LT:case Py_LE:
+        case Py_EQ:
+#if PY_MAJOR_VERSION >= 3
+#else
+        case Py_LT:case Py_LE:
+#endif
             Py_INCREF(Py_False);
             return Py_False;
-    default: // Should never happen
-        return Py_NotImplemented;
+        default: // Should only happen on Python 3
+            return Py_NotImplemented;
         }
     } else {
         /* We don't special case this comparison, we just let python handle
@@ -725,10 +733,10 @@
 static PyObject *
 StaticTuple_sizeof(StaticTuple *self)
 {
-	Py_ssize_t res;
+    Py_ssize_t res;
 
-	res = _PyObject_SIZE(&StaticTuple_Type) + (int)self->size * sizeof(void*);
-	return PyInt_FromSsize_t(res);
+    res = _PyObject_SIZE(&StaticTuple_Type) + (int)self->size * sizeof(void*);
+    return PyInt_FromSsize_t(res);
 }
 
 

=== modified file 'breezy/tests/test__static_tuple.py'
--- breezy/tests/test__static_tuple.py	2017-06-22 00:41:56 +0000
+++ breezy/tests/test__static_tuple.py	2017-06-27 01:23:29 +0000
@@ -20,6 +20,7 @@
     import cPickle as pickle
 except ImportError:
     import pickle
+import operator
 import sys
 
 from breezy import (
@@ -287,15 +288,24 @@
         k6 = self.module.StaticTuple(k3, k4)
         self.assertCompareEqual(k5, k6)
 
-    def assertCompareDifferent(self, k_small, k_big):
+    def check_strict_compare(self, k1, k2, mismatched_types):
+        """True if on Python 3 and stricter comparison semantics are used."""
+        if PY3 and mismatched_types:
+            for op in ("ge", "gt", "le", "lt"):
+                self.assertRaises(TypeError, getattr(operator, op), k1, k2)
+            return True
+        return False
+
+    def assertCompareDifferent(self, k_small, k_big, mismatched_types=False):
         self.assertFalse(k_small == k_big)
-        self.assertFalse(k_small >= k_big)
-        self.assertFalse(k_small > k_big)
         self.assertTrue(k_small != k_big)
-        self.assertTrue(k_small <= k_big)
-        self.assertTrue(k_small < k_big)
+        if not self.check_strict_compare(k_small, k_big, mismatched_types):
+            self.assertFalse(k_small >= k_big)
+            self.assertFalse(k_small > k_big)
+            self.assertTrue(k_small <= k_big)
+            self.assertTrue(k_small < k_big)
 
-    def assertCompareNoRelation(self, k1, k2):
+    def assertCompareNoRelation(self, k1, k2, mismatched_types=False):
         """Run the comparison operators, make sure they do something.
 
         However, we don't actually care what comes first or second. This is
@@ -304,20 +314,21 @@
         """
         self.assertFalse(k1 == k2)
         self.assertTrue(k1 != k2)
-        # Do the comparison, but we don't care about the result
-        k1 >= k2
-        k1 > k2
-        k1 <= k2
-        k1 < k2
+        if not self.check_strict_compare(k1, k2, mismatched_types):
+            # Do the comparison, but we don't care about the result
+            k1 >= k2
+            k1 > k2
+            k1 <= k2
+            k1 < k2
 
     def test_compare_vs_none(self):
         k1 = self.module.StaticTuple('baz', 'bing')
-        self.assertCompareDifferent(None, k1)
+        self.assertCompareDifferent(None, k1, mismatched_types=True)
     
     def test_compare_cross_class(self):
         k1 = self.module.StaticTuple('baz', 'bing')
-        self.assertCompareNoRelation(10, k1)
-        self.assertCompareNoRelation('baz', k1)
+        self.assertCompareNoRelation(10, k1, mismatched_types=True)
+        self.assertCompareNoRelation('baz', k1, mismatched_types=True)
 
     def test_compare_all_different_same_width(self):
         k1 = self.module.StaticTuple('baz', 'bing')
@@ -344,8 +355,8 @@
         k4 = self.module.StaticTuple(k1, k2)
         self.assertCompareDifferent(k3, k4)
         k5 = self.module.StaticTuple('foo', None)
-        self.assertCompareDifferent(k5, k1)
-        self.assertCompareDifferent(k5, k2)
+        self.assertCompareDifferent(k5, k1, mismatched_types=True)
+        self.assertCompareDifferent(k5, k2, mismatched_types=True)
 
     def test_compare_diff_width(self):
         k1 = self.module.StaticTuple('foo')
@@ -359,13 +370,13 @@
         k1 = self.module.StaticTuple('foo', 'bar')
         k2 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
                                      k1)
-        self.assertCompareNoRelation(k1, k2)
+        self.assertCompareNoRelation(k1, k2, mismatched_types=True)
         k3 = self.module.StaticTuple('foo')
         self.assertCompareDifferent(k3, k1)
         k4 = self.module.StaticTuple(None)
-        self.assertCompareDifferent(k4, k1)
+        self.assertCompareDifferent(k4, k1, mismatched_types=True)
         k5 = self.module.StaticTuple(1)
-        self.assertCompareNoRelation(k1, k5)
+        self.assertCompareNoRelation(k1, k5, mismatched_types=True)
 
     def test_compare_to_tuples(self):
         k1 = self.module.StaticTuple('foo')
@@ -381,7 +392,7 @@
         self.assertCompareDifferent(('foo',), k2)
         self.assertCompareDifferent(('foo', 'aaa'), k2)
         self.assertCompareDifferent(('baz', 'bing'), k2)
-        self.assertCompareDifferent(('foo', 10), k2)
+        self.assertCompareDifferent(('foo', 10), k2, mismatched_types=True)
 
         k3 = self.module.StaticTuple(k1, k2)
         self.assertCompareEqual(k3, (('foo',), ('foo', 'bar')))
@@ -397,7 +408,7 @@
         # This requires comparing a StaticTuple to a 'string', and then
         # interpreting that value in the next higher StaticTuple. This used to
         # generate a PyErr_BadIternalCall. We now fall back to *something*.
-        self.assertCompareNoRelation(k1, k2)
+        self.assertCompareNoRelation(k1, k2, mismatched_types=True)
 
     def test_hash(self):
         k = self.module.StaticTuple('foo')