Issue #23641: Cleaned out legacy dunder names from tests and docs.

Fixed 2 to 3 porting bug in pynche.ColorDB.
Added few tests for __truediv__, __floordiv__ and __matmul__.

13 files changed, 73 insertions, 111 deletions

diff --git a/Lib/_pydecimal.py b/Lib/_pydecimal.py
index 88222be..05ba4ee 100644
--- a/Lib/_pydecimal.py
+++ b/Lib/_pydecimal.py
@@ -960,13 +960,12 @@ class Decimal(object):
         return self._cmp(other) >= 0
 
     def compare(self, other, context=None):
-        """Compares one to another.
+        """Compare self to other.  Return a decimal value:
 
-        -1 => a < b
-        0  => a = b
-        1  => a > b
-        NaN => one is NaN
-        Like __cmp__, but returns Decimal instances.
+        a or b is a NaN ==> Decimal('NaN')
+        a < b           ==> Decimal('-1')
+        a == b          ==> Decimal('0')
+        a > b           ==> Decimal('1')
         """
         other = _convert_other(other, raiseit=True)
 
diff --git a/Lib/datetime.py b/Lib/datetime.py
index de57472..db13b12 100644
--- a/Lib/datetime.py
+++ b/Lib/datetime.py
@@ -651,7 +651,7 @@ class date:
     Operators:
 
     __repr__, __str__
-    __cmp__, __hash__
+    __eq__, __le__, __lt__, __ge__, __gt__, __hash__
     __add__, __radd__, __sub__ (add/radd only with timedelta arg)
 
     Methods:
@@ -786,7 +786,8 @@ class date:
         """day (1-31)"""
         return self._day
 
-    # Standard conversions, __cmp__, __hash__ (and helpers)
+    # Standard conversions, __eq__, __le__, __lt__, __ge__, __gt__,
+    # __hash__ (and helpers)
 
     def timetuple(self):
         "Return local time tuple compatible with time.localtime()."
@@ -1010,7 +1011,7 @@ class time:
     Operators:
 
     __repr__, __str__
-    __cmp__, __hash__
+    __eq__, __le__, __lt__, __ge__, __gt__, __hash__
 
     Methods:
 
diff --git a/Lib/sqlite3/test/types.py b/Lib/sqlite3/test/types.py
index a8fdad9..adad571 100644
--- a/Lib/sqlite3/test/types.py
+++ b/Lib/sqlite3/test/types.py
@@ -88,19 +88,10 @@ class DeclTypesTests(unittest.TestCase):
                 _val = _val.decode('utf-8')
             self.val = _val
 
-        def __cmp__(self, other):
-            if not isinstance(other, DeclTypesTests.Foo):
-                raise ValueError
-            if self.val == other.val:
-                return 0
-            else:
-                return 1
-
         def __eq__(self, other):
-            c = self.__cmp__(other)
-            if c is NotImplemented:
-                return c
-            return c == 0
+            if not isinstance(other, DeclTypesTests.Foo):
+                return NotImplemented
+            return self.val == other.val
 
         def __conform__(self, protocol):
             if protocol is sqlite.PrepareProtocol:
diff --git a/Lib/test/mapping_tests.py b/Lib/test/mapping_tests.py
index bc12c77..ff82f4e 100644
--- a/Lib/test/mapping_tests.py
+++ b/Lib/test/mapping_tests.py
@@ -64,7 +64,7 @@ class BasicTestMappingProtocol(unittest.TestCase):
         self.assertEqual(d, d)
         self.assertNotEqual(p, d)
         self.assertNotEqual(d, p)
-        #__non__zero__
+        #bool
         if p: self.fail("Empty mapping must compare to False")
         if not d: self.fail("Full mapping must compare to True")
         # keys(), items(), iterkeys() ...
diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
index 93f9dae..e1765f0 100644
--- a/Lib/test/test_abc.py
+++ b/Lib/test/test_abc.py
@@ -194,9 +194,9 @@ class TestABC(unittest.TestCase):
         # check that the property's __isabstractmethod__ descriptor does the
         # right thing when presented with a value that fails truth testing:
         class NotBool(object):
-            def __nonzero__(self):
+            def __bool__(self):
                 raise ValueError()
-            __len__ = __nonzero__
+            __len__ = __bool__
         with self.assertRaises(ValueError):
             class F(C):
                 def bar(self):
diff --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py
index 19b7687..dd62d2e 100644
--- a/Lib/test/test_augassign.py
+++ b/Lib/test/test_augassign.py
@@ -144,14 +144,6 @@ class AugAssignTest(unittest.TestCase):
                 output.append("__imatmul__ called")
                 return self
 
-            def __div__(self, val):
-                output.append("__div__ called")
-            def __rdiv__(self, val):
-                output.append("__rdiv__ called")
-            def __idiv__(self, val):
-                output.append("__idiv__ called")
-                return self
-
             def __floordiv__(self, val):
                 output.append("__floordiv__ called")
                 return self
diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index c7003fb..fcac5c5 100644
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -13,8 +13,12 @@ testmeths = [
     "rsub",
     "mul",
     "rmul",
+    "matmul",
+    "rmatmul",
     "truediv",
     "rtruediv",
+    "floordiv",
+    "rfloordiv",
     "mod",
     "rmod",
     "divmod",
@@ -174,15 +178,31 @@ class ClassTests(unittest.TestCase):
         1 * testme
         self.assertCallStack([("__rmul__", (testme, 1))])
 
-        if 1/2 == 0:
-            callLst[:] = []
-            testme / 1
-            self.assertCallStack([("__div__", (testme, 1))])
+        callLst[:] = []
+        testme @ 1
+        self.assertCallStack([("__matmul__", (testme, 1))])
+
+        callLst[:] = []
+        1 @ testme
+        self.assertCallStack([("__rmatmul__", (testme, 1))])
+
+        callLst[:] = []
+        testme / 1
+        self.assertCallStack([("__truediv__", (testme, 1))])
 
 
-            callLst[:] = []
-            1 / testme
-            self.assertCallStack([("__rdiv__", (testme, 1))])
+        callLst[:] = []
+        1 / testme
+        self.assertCallStack([("__rtruediv__", (testme, 1))])
+
+        callLst[:] = []
+        testme // 1
+        self.assertCallStack([("__floordiv__", (testme, 1))])
+
+
+        callLst[:] = []
+        1 // testme
+        self.assertCallStack([("__rfloordiv__", (testme, 1))])
 
         callLst[:] = []
         testme % 1
@@ -444,12 +464,16 @@ class ClassTests(unittest.TestCase):
             def __int__(self):
                 return None
             __float__ = __int__
+            __complex__ = __int__
             __str__ = __int__
             __repr__ = __int__
-            __oct__ = __int__
-            __hex__ = __int__
+            __bytes__ = __int__
+            __bool__ = __int__
+            __index__ = __int__
+        def index(x):
+            return [][x]
 
-        for f in [int, float, str, repr, oct, hex]:
+        for f in [float, complex, str, repr, bytes, bin, oct, hex, bool, index]:
             self.assertRaises(TypeError, f, BadTypeClass())
 
     def testHashStuff(self):
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 8d6205a..cdaae0a 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -21,7 +21,9 @@ class OperatorsTest(unittest.TestCase):
             'add': '+',
             'sub': '-',
             'mul': '*',
-            'div': '/',
+            'matmul': '@',
+            'truediv': '/',
+            'floordiv': '//',
             'divmod': 'divmod',
             'pow': '**',
             'lshift': '<<',
@@ -52,8 +54,6 @@ class OperatorsTest(unittest.TestCase):
             'invert': '~',
             'int': 'int',
             'float': 'float',
-            'oct': 'oct',
-            'hex': 'hex',
         }
 
         for name, expr in list(self.unops.items()):
@@ -82,12 +82,6 @@ class OperatorsTest(unittest.TestCase):
     def binop_test(self, a, b, res, expr="a+b", meth="__add__"):
         d = {'a': a, 'b': b}
 
-        # XXX Hack so this passes before 2.3 when -Qnew is specified.
-        if meth == "__div__" and 1/2 == 0.5:
-            meth = "__truediv__"
-
-        if meth == '__divmod__': pass
-
         self.assertEqual(eval(expr, d), res)
         t = type(a)
         m = getattr(t, meth)
@@ -221,7 +215,7 @@ class OperatorsTest(unittest.TestCase):
     def number_operators(self, a, b, skip=[]):
         dict = {'a': a, 'b': b}
 
-        for name, expr in list(self.binops.items()):
+        for name, expr in self.binops.items():
             if name not in skip:
                 name = "__%s__" % name
                 if hasattr(a, name):
@@ -261,7 +255,7 @@ class OperatorsTest(unittest.TestCase):
         # Testing complex operations...
         self.number_operators(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge',
                                                   'int', 'float',
-                                                  'divmod', 'mod'])
+                                                  'floordiv', 'divmod', 'mod'])
 
         class Number(complex):
             __slots__ = ['prec']
@@ -4177,9 +4171,8 @@ order (MRO) for bases """
                 ('__sub__',      'x - y',                   'x -= y'),
                 ('__mul__',      'x * y',                   'x *= y'),
                 ('__matmul__',   'x @ y',                   'x @= y'),
-                ('__truediv__',  'operator.truediv(x, y)',  None),
-                ('__floordiv__', 'operator.floordiv(x, y)', None),
-                ('__div__',      'x / y',                   'x /= y'),
+                ('__truediv__',  'x / y',                   'x /= y'),
+                ('__floordiv__', 'x // y',                  'x //= y'),
                 ('__mod__',      'x % y',                   'x %= y'),
                 ('__divmod__',   'divmod(x, y)',            None),
                 ('__pow__',      'x ** y',                  'x **= y'),
@@ -4241,8 +4234,8 @@ order (MRO) for bases """
         # Also check type_getattro for correctness.
         class Meta(type):
             pass
-        class X(object):
-            __metaclass__ = Meta
+        class X(metaclass=Meta):
+            pass
         X.a = 42
         Meta.a = Descr("a")
         self.assertEqual(X.a, 42)
diff --git a/Lib/test/test_dynamicclassattribute.py b/Lib/test/test_dynamicclassattribute.py
index 079d6c3..bc6a39b 100644
--- a/Lib/test/test_dynamicclassattribute.py
+++ b/Lib/test/test_dynamicclassattribute.py
@@ -158,9 +158,9 @@ class PropertyTests(unittest.TestCase):
         # check that the DynamicClassAttribute's __isabstractmethod__ descriptor does the
         # right thing when presented with a value that fails truth testing:
         class NotBool(object):
-            def __nonzero__(self):
+            def __bool__(self):
                 raise ValueError()
-            __len__ = __nonzero__
+            __len__ = __bool__
         with self.assertRaises(ValueError):
             class C(object):
                 def foo(self):
diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py
index bbc5385..401e6cf 100644
--- a/Lib/test/test_inspect.py
+++ b/Lib/test/test_inspect.py
@@ -800,7 +800,7 @@ class TestClassesAndFunctions(unittest.TestCase):
         class Meta(type):
             fish = 'slap'
             def __dir__(self):
-                return ['__class__', '__modules__', '__name__', 'fish']
+                return ['__class__', '__module__', '__name__', 'fish']
         class Class(metaclass=Meta):
             pass
         should_find = inspect.Attribute('fish', 'data', Meta, 'slap')
diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py
index 6a0130e..7bbee5a 100644
--- a/Lib/test/test_itertools.py
+++ b/Lib/test/test_itertools.py
@@ -698,7 +698,7 @@ class TestBasicOps(unittest.TestCase):
         # iter.__next__ failure on inner object
         self.assertRaises(ExpectedError, gulp, delayed_raise(1))
 
-        # __cmp__ failure
+        # __eq__ failure
         class DummyCmp:
             def __eq__(self, dst):
                 raise ExpectedError
diff --git a/Lib/test/test_property.py b/Lib/test/test_property.py
index 96eeb88..cee7203 100644
--- a/Lib/test/test_property.py
+++ b/Lib/test/test_property.py
@@ -140,9 +140,9 @@ class PropertyTests(unittest.TestCase):
         # check that the property's __isabstractmethod__ descriptor does the
         # right thing when presented with a value that fails truth testing:
         class NotBool(object):
-            def __nonzero__(self):
+            def __bool__(self):
                 raise ValueError()
-            __len__ = __nonzero__
+            __len__ = __bool__
         with self.assertRaises(ValueError):
             class C(object):
                 def foo(self):
diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py
index e4cd99b..e263da2 100644
--- a/Lib/test/test_unicode.py
+++ b/Lib/test/test_unicode.py
@@ -2017,64 +2017,26 @@ class UnicodeTest(string_tests.CommonTest,
             self.fail("Should have raised UnicodeDecodeError")
 
     def test_conversion(self):
-        # Make sure __unicode__() works properly
-        class Foo0:
+        # Make sure __str__() works properly
+        class ObjectToStr:
             def __str__(self):
                 return "foo"
 
-        class Foo1:
+        class StrSubclassToStr(str):
             def __str__(self):
                 return "foo"
 
-        class Foo2(object):
-            def __str__(self):
-                return "foo"
-
-        class Foo3(object):
-            def __str__(self):
-                return "foo"
-
-        class Foo4(str):
-            def __str__(self):
-                return "foo"
-
-        class Foo5(str):
-            def __str__(self):
-                return "foo"
-
-        class Foo6(str):
-            def __str__(self):
-                return "foos"
-
-            def __str__(self):
-                return "foou"
-
-        class Foo7(str):
-            def __str__(self):
-                return "foos"
-            def __str__(self):
-                return "foou"
-
-        class Foo8(str):
+        class StrSubclassToStrSubclass(str):
             def __new__(cls, content=""):
                 return str.__new__(cls, 2*content)
             def __str__(self):
                 return self
 
-        class Foo9(str):
-            def __str__(self):
-                return "not unicode"
-
-        self.assertEqual(str(Foo0()), "foo")
-        self.assertEqual(str(Foo1()), "foo")
-        self.assertEqual(str(Foo2()), "foo")
-        self.assertEqual(str(Foo3()), "foo")
-        self.assertEqual(str(Foo4("bar")), "foo")
-        self.assertEqual(str(Foo5("bar")), "foo")
-        self.assertEqual(str(Foo6("bar")), "foou")
-        self.assertEqual(str(Foo7("bar")), "foou")
-        self.assertEqual(str(Foo8("foo")), "foofoo")
-        self.assertEqual(str(Foo9("foo")), "not unicode")
+        self.assertEqual(str(ObjectToStr()), "foo")
+        self.assertEqual(str(StrSubclassToStr("bar")), "foo")
+        s = str(StrSubclassToStrSubclass("foo"))
+        self.assertEqual(s, "foofoo")
+        self.assertIs(type(s), StrSubclassToStrSubclass)
 
     def test_unicode_repr(self):
         class s1: