mirror of
https://github.com/python/cpython.git
synced 2025-07-29 06:05:00 +00:00
672237dc6c
WarningsRecorder object. This makes the API simpler to use as no special object must be learned. Closes issue 3781. Review by Benjamin Peterson.
144 lines
4.6 KiB
Python
Executable file
144 lines
4.6 KiB
Python
Executable file
#!/usr/bin/env python
|
|
# UserString is a wrapper around the native builtin string type.
|
|
# UserString instances should behave similar to builtin string objects.
|
|
|
|
import string
|
|
from test import test_support, string_tests
|
|
from UserString import UserString, MutableString
|
|
import warnings
|
|
|
|
class UserStringTest(
|
|
string_tests.CommonTest,
|
|
string_tests.MixinStrUnicodeUserStringTest,
|
|
string_tests.MixinStrStringUserStringTest,
|
|
string_tests.MixinStrUserStringTest
|
|
):
|
|
|
|
type2test = UserString
|
|
|
|
# Overwrite the three testing methods, because UserString
|
|
# can't cope with arguments propagated to UserString
|
|
# (and we don't test with subclasses)
|
|
def checkequal(self, result, object, methodname, *args):
|
|
result = self.fixtype(result)
|
|
object = self.fixtype(object)
|
|
# we don't fix the arguments, because UserString can't cope with it
|
|
realresult = getattr(object, methodname)(*args)
|
|
self.assertEqual(
|
|
result,
|
|
realresult
|
|
)
|
|
|
|
def checkraises(self, exc, object, methodname, *args):
|
|
object = self.fixtype(object)
|
|
# we don't fix the arguments, because UserString can't cope with it
|
|
self.assertRaises(
|
|
exc,
|
|
getattr(object, methodname),
|
|
*args
|
|
)
|
|
|
|
def checkcall(self, object, methodname, *args):
|
|
object = self.fixtype(object)
|
|
# we don't fix the arguments, because UserString can't cope with it
|
|
getattr(object, methodname)(*args)
|
|
|
|
class MutableStringTest(UserStringTest):
|
|
type2test = MutableString
|
|
|
|
# MutableStrings can be hashed => deactivate test
|
|
def test_hash(self):
|
|
pass
|
|
|
|
def test_setitem(self):
|
|
s = self.type2test("foo")
|
|
self.assertRaises(IndexError, s.__setitem__, -4, "bar")
|
|
self.assertRaises(IndexError, s.__setitem__, 3, "bar")
|
|
s[-1] = "bar"
|
|
self.assertEqual(s, "fobar")
|
|
s[0] = "bar"
|
|
self.assertEqual(s, "barobar")
|
|
|
|
def test_delitem(self):
|
|
s = self.type2test("foo")
|
|
self.assertRaises(IndexError, s.__delitem__, -4)
|
|
self.assertRaises(IndexError, s.__delitem__, 3)
|
|
del s[-1]
|
|
self.assertEqual(s, "fo")
|
|
del s[0]
|
|
self.assertEqual(s, "o")
|
|
del s[0]
|
|
self.assertEqual(s, "")
|
|
|
|
def test_setslice(self):
|
|
s = self.type2test("foo")
|
|
s[:] = "bar"
|
|
self.assertEqual(s, "bar")
|
|
s[1:2] = "foo"
|
|
self.assertEqual(s, "bfoor")
|
|
s[1:-1] = UserString("a")
|
|
self.assertEqual(s, "bar")
|
|
s[0:10] = 42
|
|
self.assertEqual(s, "42")
|
|
|
|
def test_delslice(self):
|
|
s = self.type2test("foobar")
|
|
del s[3:10]
|
|
self.assertEqual(s, "foo")
|
|
del s[-1:10]
|
|
self.assertEqual(s, "fo")
|
|
|
|
def test_extended_set_del_slice(self):
|
|
indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
|
|
orig = string.ascii_letters + string.digits
|
|
for start in indices:
|
|
for stop in indices:
|
|
# Use indices[1:] when MutableString can handle real
|
|
# extended slices
|
|
for step in (None, 1, -1):
|
|
s = self.type2test(orig)
|
|
L = list(orig)
|
|
# Make sure we have a slice of exactly the right length,
|
|
# but with (hopefully) different data.
|
|
data = L[start:stop:step]
|
|
data.reverse()
|
|
L[start:stop:step] = data
|
|
s[start:stop:step] = "".join(data)
|
|
self.assertEquals(s, "".join(L))
|
|
|
|
del L[start:stop:step]
|
|
del s[start:stop:step]
|
|
self.assertEquals(s, "".join(L))
|
|
|
|
def test_immutable(self):
|
|
s = self.type2test("foobar")
|
|
s2 = s.immutable()
|
|
self.assertEqual(s, s2)
|
|
self.assert_(isinstance(s2, UserString))
|
|
|
|
def test_iadd(self):
|
|
s = self.type2test("foo")
|
|
s += "bar"
|
|
self.assertEqual(s, "foobar")
|
|
s += UserString("baz")
|
|
self.assertEqual(s, "foobarbaz")
|
|
s += 42
|
|
self.assertEqual(s, "foobarbaz42")
|
|
|
|
def test_imul(self):
|
|
s = self.type2test("foo")
|
|
s *= 1
|
|
self.assertEqual(s, "foo")
|
|
s *= 2
|
|
self.assertEqual(s, "foofoo")
|
|
s *= -1
|
|
self.assertEqual(s, "")
|
|
|
|
def test_main():
|
|
with warnings.catch_warnings():
|
|
warnings.filterwarnings("ignore", ".*MutableString",
|
|
DeprecationWarning)
|
|
test_support.run_unittest(UserStringTest, MutableStringTest)
|
|
|
|
if __name__ == "__main__":
|
|
test_main()
|