mirror of
https://github.com/python/cpython.git
synced 2026-04-13 23:31:02 +00:00
gh-145144: Add more tests for UserList, UserDict, etc (GH-145145)
This commit is contained in:
Serhiy Storchaka
GitHub
parent
97c725cd39
commit
161329cde2
6 changed files with 380 additions and 34 deletions
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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):
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -2,12 +2,36 @@
|
|||
|
||||
from collections import UserList
|
||||
from test import list_tests
|
||||
from test import support
|
||||
import unittest
|
||||
|
||||
|
||||
class UserListSubclass(UserList):
|
||||
pass
|
||||
|
||||
class UserListSubclass2(UserList):
|
||||
pass
|
||||
|
||||
|
||||
class UserListTest(list_tests.CommonTest):
|
||||
type2test = UserList
|
||||
|
||||
def test_data(self):
|
||||
u = UserList()
|
||||
self.assertEqual(u.data, [])
|
||||
self.assertIs(type(u.data), list)
|
||||
a = [1, 2]
|
||||
u = UserList(a)
|
||||
self.assertEqual(u.data, a)
|
||||
self.assertIsNot(u.data, a)
|
||||
self.assertIs(type(u.data), list)
|
||||
u = UserList(u)
|
||||
self.assertEqual(u.data, a)
|
||||
self.assertIs(type(u.data), list)
|
||||
u = UserList("spam")
|
||||
self.assertEqual(u.data, list("spam"))
|
||||
self.assertIs(type(u.data), list)
|
||||
|
||||
def test_getslice(self):
|
||||
super().test_getslice()
|
||||
l = [0, 1, 2, 3, 4]
|
||||
|
|
@ -24,34 +48,74 @@ def test_slice_type(self):
|
|||
self.assertIsInstance(u[:], u.__class__)
|
||||
self.assertEqual(u[:],u)
|
||||
|
||||
def test_add_specials(self):
|
||||
u = UserList("spam")
|
||||
u2 = u + "eggs"
|
||||
self.assertEqual(u2, list("spameggs"))
|
||||
def test_mixed_add(self):
|
||||
for t in UserList, list, str, tuple, iter:
|
||||
with self.subTest(t.__name__):
|
||||
u = UserList("spam") + t("eggs")
|
||||
self.assertEqual(u, list("spameggs"))
|
||||
self.assertIs(type(u), UserList)
|
||||
|
||||
def test_radd_specials(self):
|
||||
u = UserList("eggs")
|
||||
u2 = "spam" + u
|
||||
self.assertEqual(u2, list("spameggs"))
|
||||
u2 = u.__radd__(UserList("spam"))
|
||||
self.assertEqual(u2, list("spameggs"))
|
||||
u = t("spam") + UserList("eggs")
|
||||
self.assertEqual(u, list("spameggs"))
|
||||
self.assertIs(type(u), UserList)
|
||||
|
||||
def test_iadd(self):
|
||||
super().test_iadd()
|
||||
u = [0, 1]
|
||||
u += UserList([0, 1])
|
||||
self.assertEqual(u, [0, 1, 0, 1])
|
||||
u = UserList("spam") + UserListSubclass("eggs")
|
||||
self.assertEqual(u, list("spameggs"))
|
||||
self.assertIs(type(u), UserList)
|
||||
|
||||
def test_mixedcmp(self):
|
||||
u = UserListSubclass("spam") + UserList("eggs")
|
||||
self.assertEqual(u, list("spameggs"))
|
||||
self.assertIs(type(u), UserListSubclass)
|
||||
|
||||
u = UserListSubclass("spam") + UserListSubclass2("eggs")
|
||||
self.assertEqual(u, list("spameggs"))
|
||||
self.assertIs(type(u), UserListSubclass)
|
||||
|
||||
u2 = UserList("eggs").__radd__(UserList("spam"))
|
||||
self.assertEqual(u2, list("spameggs"))
|
||||
self.assertIs(type(u), UserListSubclass)
|
||||
|
||||
u2 = UserListSubclass("eggs").__radd__(UserListSubclass2("spam"))
|
||||
self.assertEqual(u2, list("spameggs"))
|
||||
self.assertIs(type(u), UserListSubclass)
|
||||
|
||||
def test_mixed_iadd(self):
|
||||
for t in UserList, list, str, tuple, iter:
|
||||
with self.subTest(t.__name__):
|
||||
u = u2 = UserList("spam")
|
||||
u += t("eggs")
|
||||
self.assertEqual(u, list("spameggs"))
|
||||
self.assertIs(type(u), UserList)
|
||||
self.assertIs(u, u2)
|
||||
|
||||
u = t("spam")
|
||||
u += UserList("eggs")
|
||||
self.assertEqual(u, list("spameggs"))
|
||||
self.assertIs(type(u), UserList)
|
||||
|
||||
u = u2 = UserList("spam")
|
||||
u += UserListSubclass("eggs")
|
||||
self.assertEqual(u, list("spameggs"))
|
||||
self.assertIs(type(u), UserList)
|
||||
self.assertIs(u, u2)
|
||||
|
||||
u = u2 = UserListSubclass("spam")
|
||||
u += UserList("eggs")
|
||||
self.assertEqual(u, list("spameggs"))
|
||||
self.assertIs(type(u), UserListSubclass)
|
||||
self.assertIs(u, u2)
|
||||
|
||||
u = u2 = UserListSubclass("spam")
|
||||
u += UserListSubclass2("eggs")
|
||||
self.assertEqual(u, list("spameggs"))
|
||||
self.assertIs(type(u), UserListSubclass)
|
||||
self.assertIs(u, u2)
|
||||
|
||||
def test_mixed_cmp(self):
|
||||
u = self.type2test([0, 1])
|
||||
self.assertEqual(u, [0, 1])
|
||||
self.assertNotEqual(u, [0])
|
||||
self.assertNotEqual(u, [0, 2])
|
||||
|
||||
def test_mixedadd(self):
|
||||
u = self.type2test([0, 1])
|
||||
self.assertEqual(u + [], u)
|
||||
self.assertEqual(u + [2], [0, 1, 2])
|
||||
self._assert_cmp(u, [0, 1], 0)
|
||||
self._assert_cmp(u, [0], 1)
|
||||
self._assert_cmp(u, [0, 2], -1)
|
||||
|
||||
def test_getitemoverwriteiter(self):
|
||||
# Verify that __getitem__ overrides *are* recognized by __iter__
|
||||
|
|
@ -60,6 +124,43 @@ def __getitem__(self, key):
|
|||
return str(key) + '!!!'
|
||||
self.assertEqual(next(iter(T((1,2)))), "0!!!")
|
||||
|
||||
def test_implementation(self):
|
||||
u = UserList([1])
|
||||
with (support.swap_attr(UserList, '__len__', None),
|
||||
support.swap_attr(UserList, 'insert', None)):
|
||||
u.append(2)
|
||||
self.assertEqual(u, [1, 2])
|
||||
with support.swap_attr(UserList, 'append', None):
|
||||
u.extend([3, 4])
|
||||
self.assertEqual(u, [1, 2, 3, 4])
|
||||
with support.swap_attr(UserList, 'append', None):
|
||||
u.extend(UserList([3, 4]))
|
||||
self.assertEqual(u, [1, 2, 3, 4, 3, 4])
|
||||
with support.swap_attr(UserList, '__iter__', None):
|
||||
c = u.count(3)
|
||||
self.assertEqual(c, 2)
|
||||
with (support.swap_attr(UserList, '__iter__', None),
|
||||
support.swap_attr(UserList, '__getitem__', None)):
|
||||
i = u.index(4)
|
||||
self.assertEqual(i, 3)
|
||||
with (support.swap_attr(UserList, 'index', None),
|
||||
support.swap_attr(UserList, '__getitem__', None)):
|
||||
u.remove(3)
|
||||
self.assertEqual(u, [1, 2, 4, 3, 4])
|
||||
with (support.swap_attr(UserList, '__getitem__', None),
|
||||
support.swap_attr(UserList, '__delitem__', None)):
|
||||
u.pop()
|
||||
self.assertEqual(u, [1, 2, 4, 3])
|
||||
with (support.swap_attr(UserList, '__len__', None),
|
||||
support.swap_attr(UserList, '__getitem__', None),
|
||||
support.swap_attr(UserList, '__setitem__', None)):
|
||||
u.reverse()
|
||||
self.assertEqual(u, [3, 4, 2, 1])
|
||||
with (support.swap_attr(UserList, '__len__', None),
|
||||
support.swap_attr(UserList, 'pop', None)):
|
||||
u.clear()
|
||||
self.assertEqual(u, [])
|
||||
|
||||
def test_userlist_copy(self):
|
||||
u = self.type2test([6, 8, 1, 9, 1])
|
||||
v = u.copy()
|
||||
|
|
|
|||
|
|
@ -3,9 +3,18 @@
|
|||
|
||||
import unittest
|
||||
from test import string_tests
|
||||
from test import support
|
||||
|
||||
from collections import UserString
|
||||
|
||||
|
||||
class UserStringSubclass(UserString):
|
||||
pass
|
||||
|
||||
class UserStringSubclass2(UserString):
|
||||
pass
|
||||
|
||||
|
||||
class UserStringTest(
|
||||
string_tests.StringLikeTest,
|
||||
unittest.TestCase
|
||||
|
|
@ -40,6 +49,78 @@ def checkcall(self, object, methodname, *args):
|
|||
# we don't fix the arguments, because UserString can't cope with it
|
||||
getattr(object, methodname)(*args)
|
||||
|
||||
def test_data(self):
|
||||
u = UserString("spam")
|
||||
self.assertEqual(u.data, "spam")
|
||||
self.assertIs(type(u.data), str)
|
||||
u = UserString(u)
|
||||
self.assertEqual(u.data, "spam")
|
||||
self.assertIs(type(u.data), str)
|
||||
u = UserString(42)
|
||||
self.assertEqual(u.data, "42")
|
||||
self.assertIs(type(u.data), str)
|
||||
|
||||
def test_mixed_add(self):
|
||||
u = UserString("spam") + "eggs"
|
||||
self.assertEqual(u, "spameggs")
|
||||
self.assertIs(type(u), UserString)
|
||||
|
||||
u = "spam" + UserString("eggs")
|
||||
self.assertEqual(u, "spameggs")
|
||||
self.assertIs(type(u), UserString)
|
||||
|
||||
u = UserString("spam") + UserStringSubclass("eggs")
|
||||
self.assertEqual(u, "spameggs")
|
||||
self.assertIs(type(u), UserString)
|
||||
|
||||
u = UserStringSubclass("spam") + UserString("eggs")
|
||||
self.assertEqual(u, "spameggs")
|
||||
self.assertIs(type(u), UserStringSubclass)
|
||||
|
||||
u = UserStringSubclass("spam") + UserStringSubclass2("eggs")
|
||||
self.assertEqual(u, "spameggs")
|
||||
self.assertIs(type(u), UserStringSubclass)
|
||||
|
||||
u2 = UserString("eggs").__radd__(UserString("spam"))
|
||||
self.assertEqual(u2, "spameggs")
|
||||
self.assertIs(type(u), UserStringSubclass)
|
||||
|
||||
u2 = UserStringSubclass("eggs").__radd__(UserStringSubclass2("spam"))
|
||||
self.assertEqual(u2, "spameggs")
|
||||
self.assertIs(type(u), UserStringSubclass)
|
||||
|
||||
def test_mixed_iadd(self):
|
||||
u = UserString("spam")
|
||||
u += "eggs"
|
||||
self.assertEqual(u, "spameggs")
|
||||
self.assertIs(type(u), UserString)
|
||||
|
||||
u = "spam"
|
||||
u += UserString("eggs")
|
||||
self.assertEqual(u, "spameggs")
|
||||
self.assertIs(type(u), UserString)
|
||||
|
||||
u = UserString("spam")
|
||||
u += UserStringSubclass("eggs")
|
||||
self.assertEqual(u, "spameggs")
|
||||
self.assertIs(type(u), UserString)
|
||||
|
||||
u = UserStringSubclass("spam")
|
||||
u += UserString("eggs")
|
||||
self.assertEqual(u, "spameggs")
|
||||
self.assertIs(type(u), UserStringSubclass)
|
||||
|
||||
u = UserStringSubclass("spam")
|
||||
u += UserStringSubclass2("eggs")
|
||||
self.assertEqual(u, "spameggs")
|
||||
self.assertIs(type(u), UserStringSubclass)
|
||||
|
||||
def test_mixed_cmp(self):
|
||||
a = self.fixtype('ab')
|
||||
self._assert_cmp(a, 'ab', 0)
|
||||
self._assert_cmp(a, 'a', 1)
|
||||
self._assert_cmp(a, 'ac', -1)
|
||||
|
||||
def test_rmod(self):
|
||||
class ustr2(UserString):
|
||||
pass
|
||||
|
|
@ -66,6 +147,20 @@ def test_encode_explicit_none_args(self):
|
|||
# Check that errors defaults to 'strict'
|
||||
self.checkraises(UnicodeError, '\ud800', 'encode', None, None)
|
||||
|
||||
def test_implementation(self):
|
||||
s = UserString('ababahalamaha')
|
||||
with support.swap_attr(UserString, '__iter__', None):
|
||||
c = s.count('a')
|
||||
c2 = s.count(UserString('a'))
|
||||
self.assertEqual(c, 7)
|
||||
self.assertEqual(c2, 7)
|
||||
with (support.swap_attr(UserString, '__iter__', None),
|
||||
support.swap_attr(UserString, '__getitem__', None)):
|
||||
i = s.index('h')
|
||||
i2 = s.index(UserString('h'))
|
||||
self.assertEqual(i, 5)
|
||||
self.assertEqual(i2, 5)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue