gh-145144: Add more tests for UserList, UserDict, etc

Lib/test/seq_tests.py

@@ -261,23 +261,20 @@ def test_minmax(self):
         self.assertEqual(min(u), 0)
         self.assertEqual(max(u), 2)
 
-    def test_addmul(self):
+    def test_add(self):
         u1 = self.type2test([0])
         u2 = self.type2test([0, 1])
         self.assertEqual(u1, u1 + self.type2test())
         self.assertEqual(u1, self.type2test() + u1)
         self.assertEqual(u1 + self.type2test([1]), u2)
         self.assertEqual(self.type2test([-1]) + u1, self.type2test([-1, 0]))
-        self.assertEqual(self.type2test(), u2*0)
-        self.assertEqual(self.type2test(), 0*u2)
+
+    def test_mul(self):
+        u2 = self.type2test([0, 1])
         self.assertEqual(self.type2test(), u2*0)
         self.assertEqual(self.type2test(), 0*u2)
         self.assertEqual(u2, u2*1)
         self.assertEqual(u2, 1*u2)
-        self.assertEqual(u2, u2*1)
-        self.assertEqual(u2, 1*u2)
-        self.assertEqual(u2+u2, u2*2)
-        self.assertEqual(u2+u2, 2*u2)
         self.assertEqual(u2+u2, u2*2)
         self.assertEqual(u2+u2, 2*u2)
         self.assertEqual(u2+u2+u2, u2*3)
@@ -286,8 +283,9 @@ def test_addmul(self):
         class subclass(self.type2test):
             pass
         u3 = subclass([0, 1])
-        self.assertEqual(u3, u3*1)
-        self.assertIsNot(u3, u3*1)
+        r = u3*1
+        self.assertEqual(r, u3)
+        self.assertIsNot(r, u3)
 
     def test_iadd(self):
         u = self.type2test([0, 1])
@@ -348,6 +346,21 @@ def test_subscript(self):
         self.assertRaises(ValueError, a.__getitem__, slice(0, 10, 0))
         self.assertRaises(TypeError, a.__getitem__, 'x')
 
+    def _assert_cmp(self, a, b, r):
+        self.assertIs(a == b, r == 0)
+        self.assertIs(a != b, r != 0)
+        self.assertIs(a > b, r > 0)
+        self.assertIs(a <= b, r <= 0)
+        self.assertIs(a < b, r < 0)
+        self.assertIs(a >= b, r >= 0)
+
+    def test_cmp(self):
+        a = self.type2test([0, 1])
+        self._assert_cmp(a, a, 0)
+        self._assert_cmp(a, self.type2test([0, 1]), 0)
+        self._assert_cmp(a, self.type2test([0]), 1)
+        self._assert_cmp(a, self.type2test([0, 2]), -1)
+
     def test_count(self):
         a = self.type2test([0, 1, 2])*3
         self.assertEqual(a.count(0), 3)

Lib/test/string_tests.py

@@ -102,6 +102,43 @@ def _get_teststrings(self, charset, digits):
         teststrings = [self.fixtype(ts) for ts in teststrings]
         return teststrings
 
+    def test_add(self):
+        s = self.fixtype('ab')
+        self.assertEqual(s + self.fixtype(''), s)
+        self.assertEqual(self.fixtype('') + s, s)
+        self.assertEqual(s + self.fixtype('cd'), self.fixtype('abcd'))
+
+    def test_mul(self):
+        s = self.fixtype('ab')
+        self.assertEqual(s*0, self.fixtype(''))
+        self.assertEqual(0*s, self.fixtype(''))
+        self.assertEqual(s*1, s)
+        self.assertEqual(1*s, s)
+        self.assertEqual(s*2, self.fixtype('abab'))
+        self.assertEqual(2*s, self.fixtype('abab'))
+
+        class subclass(self.type2test):
+            pass
+        s = subclass(self.fixtype('ab'))
+        r = s*1
+        self.assertEqual(r, s)
+        self.assertIsNot(r, s)
+
+    def _assert_cmp(self, a, b, r):
+        self.assertIs(a == b, r == 0)
+        self.assertIs(a != b, r != 0)
+        self.assertIs(a > b, r > 0)
+        self.assertIs(a <= b, r <= 0)
+        self.assertIs(a < b, r < 0)
+        self.assertIs(a >= b, r >= 0)
+
+    def test_cmp(self):
+        a = self.fixtype('ab')
+        self._assert_cmp(a, a, 0)
+        self._assert_cmp(a, self.fixtype('ab'), 0)
+        self._assert_cmp(a, self.fixtype('a'), 1)
+        self._assert_cmp(a, self.fixtype('ac'), -1)
+
     def test_count(self):
         self.checkequal(3, 'aaa', 'count', 'a')
         self.checkequal(0, 'aaa', 'count', 'b')
@@ -1304,6 +1341,7 @@ def test_extended_getslice(self):
                                     slice(start, stop, step))
 
     def test_mul(self):
+        super().test_mul()
         self.checkequal('', 'abc', '__mul__', -1)
         self.checkequal('', 'abc', '__mul__', 0)
         self.checkequal('abc', 'abc', '__mul__', 1)

Lib/test/test_bytes.py

@@ -2363,13 +2363,20 @@ def fixtype(self, obj):
 
     contains_bytes = True
 
+    def test_mixed_cmp(self):
+        a = self.type2test(b'ab')
+        for t in bytes, bytearray, BytesSubclass, ByteArraySubclass:
+            with self.subTest(t.__name__):
+                self._assert_cmp(a, t(b'ab'), 0)
+                self._assert_cmp(a, t(b'a'), 1)
+                self._assert_cmp(a, t(b'ac'), -1)
+
 class ByteArrayAsStringTest(FixedStringTest, unittest.TestCase):
     type2test = bytearray
 
 class BytesAsStringTest(FixedStringTest, unittest.TestCase):
     type2test = bytes
 
-
 class SubclassTest:
 
     def test_basic(self):

Lib/test/test_userdict.py

@@ -1,8 +1,18 @@
 # Check every path through every method of UserDict
 
+from collections import UserDict
 from test import mapping_tests
 import unittest
 import collections
+import types
+
+
+class UserDictSubclass(UserDict):
+    pass
+
+class UserDictSubclass2(UserDict):
+    pass
+
 
 d0 = {}
 d1 = {"one": 1}
@@ -155,6 +165,25 @@ def test_init(self):
         self.assertRaises(TypeError, collections.UserDict, (), ())
         self.assertRaises(TypeError, collections.UserDict.__init__)
 
+    def test_data(self):
+        u = UserDict()
+        self.assertEqual(u.data, {})
+        self.assertIs(type(u.data), dict)
+        d = {'a': 1, 'b': 2}
+        u = UserDict(d)
+        self.assertEqual(u.data, d)
+        self.assertIsNot(u.data, d)
+        self.assertIs(type(u.data), dict)
+        u = UserDict(u)
+        self.assertEqual(u.data, d)
+        self.assertIs(type(u.data), dict)
+        u = UserDict([('a', 1), ('b', 2)])
+        self.assertEqual(u.data, d)
+        self.assertIs(type(u.data), dict)
+        u = UserDict(a=1, b=2)
+        self.assertEqual(u.data, d)
+        self.assertIs(type(u.data), dict)
+
     def test_update(self):
         for kw in 'self', 'dict', 'other', 'iterable':
             d = collections.UserDict()
@@ -215,6 +244,69 @@ class G(collections.UserDict):
 
     test_repr_deep = mapping_tests.TestHashMappingProtocol.test_repr_deep
 
+    def test_mixed_or(self):
+        for t in UserDict, dict, types.MappingProxyType:
+            with self.subTest(t.__name__):
+                u = UserDict({0: 'a', 1: 'b'}) | t({1: 'c', 2: 'd'})
+                self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+                self.assertIs(type(u), UserDict)
+
+                u = t({0: 'a', 1: 'b'}) | UserDict({1: 'c', 2: 'd'})
+                self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+                self.assertIs(type(u), UserDict)
+
+        u = UserDict({0: 'a', 1: 'b'}) | UserDictSubclass({1: 'c', 2: 'd'})
+        self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+        self.assertIs(type(u), UserDict)
+
+        u = UserDictSubclass({0: 'a', 1: 'b'}) | UserDict({1: 'c', 2: 'd'})
+        self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+        self.assertIs(type(u), UserDictSubclass)
+
+        u = UserDictSubclass({0: 'a', 1: 'b'}) |  UserDictSubclass2({1: 'c', 2: 'd'})
+        self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+        self.assertIs(type(u), UserDictSubclass)
+
+        u = UserDict({1: 'c', 2: 'd'}).__ror__(UserDict({0: 'a', 1: 'b'}))
+        self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+        self.assertIs(type(u), UserDict)
+
+        u = UserDictSubclass({1: 'c', 2: 'd'}).__ror__(UserDictSubclass2({0: 'a', 1: 'b'}))
+        self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+        self.assertIs(type(u), UserDictSubclass)
+
+    def test_mixed_ior(self):
+        for t in UserDict, dict, types.MappingProxyType:
+            with self.subTest(t.__name__):
+                u = u2 = UserDict({0: 'a', 1: 'b'})
+                u |= t({1: 'c', 2: 'd'})
+                self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+                self.assertIs(type(u), UserDict)
+                self.assertIs(u, u2)
+
+        u = dict({0: 'a', 1: 'b'})
+        u |= UserDict({1: 'c', 2: 'd'})
+        self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+        self.assertIs(type(u), dict)
+
+        u = u2 = UserDict({0: 'a', 1: 'b'})
+        u |= UserDictSubclass({1: 'c', 2: 'd'})
+        self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+        self.assertIs(type(u), UserDict)
+        self.assertIs(u, u2)
+
+        u = u2 = UserDictSubclass({0: 'a', 1: 'b'})
+        u |= UserDict({1: 'c', 2: 'd'})
+        self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+        self.assertIs(type(u), UserDictSubclass)
+        self.assertIs(u, u2)
+
+        u = u2 = UserDictSubclass({0: 'a', 1: 'b'})
+        u |= UserDictSubclass2({1: 'c', 2: 'd'})
+        self.assertEqual(u, {0: 'a', 1: 'c', 2: 'd'})
+        self.assertIs(type(u), UserDictSubclass)
+        self.assertIs(u, u2)
+
 
 if __name__ == "__main__":
     unittest.main()