/Lib/test/test_userstring.py

  1#!/usr/bin/env python
  2# UserString is a wrapper around the native builtin string type.
  3# UserString instances should behave similar to builtin string objects.
  4
  5import string
  6from test import test_support, string_tests
  7from UserString import UserString, MutableString
  8import warnings
  9
 10class UserStringTest(
 11    string_tests.CommonTest,
 12    string_tests.MixinStrUnicodeUserStringTest,
 13    string_tests.MixinStrStringUserStringTest,
 14    string_tests.MixinStrUserStringTest
 15    ):
 16
 17    type2test = UserString
 18
 19    # Overwrite the three testing methods, because UserString
 20    # can't cope with arguments propagated to UserString
 21    # (and we don't test with subclasses)
 22    def checkequal(self, result, object, methodname, *args):
 23        result = self.fixtype(result)
 24        object = self.fixtype(object)
 25        # we don't fix the arguments, because UserString can't cope with it
 26        realresult = getattr(object, methodname)(*args)
 27        self.assertEqual(
 28            result,
 29            realresult
 30        )
 31
 32    def checkraises(self, exc, object, methodname, *args):
 33        object = self.fixtype(object)
 34        # we don't fix the arguments, because UserString can't cope with it
 35        self.assertRaises(
 36            exc,
 37            getattr(object, methodname),
 38            *args
 39        )
 40
 41    def checkcall(self, object, methodname, *args):
 42        object = self.fixtype(object)
 43        # we don't fix the arguments, because UserString can't cope with it
 44        getattr(object, methodname)(*args)
 45
 46class MutableStringTest(UserStringTest):
 47    type2test = MutableString
 48
 49    # MutableStrings can be hashed => deactivate test
 50    def test_hash(self):
 51        pass
 52
 53    def test_setitem(self):
 54        s = self.type2test("foo")
 55        self.assertRaises(IndexError, s.__setitem__, -4, "bar")
 56        self.assertRaises(IndexError, s.__setitem__, 3, "bar")
 57        s[-1] = "bar"
 58        self.assertEqual(s, "fobar")
 59        s[0] = "bar"
 60        self.assertEqual(s, "barobar")
 61
 62    def test_delitem(self):
 63        s = self.type2test("foo")
 64        self.assertRaises(IndexError, s.__delitem__, -4)
 65        self.assertRaises(IndexError, s.__delitem__, 3)
 66        del s[-1]
 67        self.assertEqual(s, "fo")
 68        del s[0]
 69        self.assertEqual(s, "o")
 70        del s[0]
 71        self.assertEqual(s, "")
 72
 73    def test_setslice(self):
 74        s = self.type2test("foo")
 75        s[:] = "bar"
 76        self.assertEqual(s, "bar")
 77        s[1:2] = "foo"
 78        self.assertEqual(s, "bfoor")
 79        s[1:-1] = UserString("a")
 80        self.assertEqual(s, "bar")
 81        s[0:10] = 42
 82        self.assertEqual(s, "42")
 83
 84    def test_delslice(self):
 85        s = self.type2test("foobar")
 86        del s[3:10]
 87        self.assertEqual(s, "foo")
 88        del s[-1:10]
 89        self.assertEqual(s, "fo")
 90
 91    def test_extended_set_del_slice(self):
 92        indices = (0, None, 1, 3, 19, 100, -1, -2, -31, -100)
 93        orig = string.ascii_letters + string.digits
 94        for start in indices:
 95            for stop in indices:
 96                # Use indices[1:] when MutableString can handle real
 97                # extended slices
 98                for step in (None, 1, -1):
 99                    s = self.type2test(orig)
100                    L = list(orig)
101                    # Make sure we have a slice of exactly the right length,
102                    # but with (hopefully) different data.
103                    data = L[start:stop:step]
104                    data.reverse()
105                    L[start:stop:step] = data
106                    s[start:stop:step] = "".join(data)
107                    self.assertEquals(s, "".join(L))
108
109                    del L[start:stop:step]
110                    del s[start:stop:step]
111                    self.assertEquals(s, "".join(L))
112
113    def test_immutable(self):
114        s = self.type2test("foobar")
115        s2 = s.immutable()
116        self.assertEqual(s, s2)
117        self.assert_(isinstance(s2, UserString))
118
119    def test_iadd(self):
120        s = self.type2test("foo")
121        s += "bar"
122        self.assertEqual(s, "foobar")
123        s += UserString("baz")
124        self.assertEqual(s, "foobarbaz")
125        s += 42
126        self.assertEqual(s, "foobarbaz42")
127
128    def test_imul(self):
129        s = self.type2test("foo")
130        s *= 1
131        self.assertEqual(s, "foo")
132        s *= 2
133        self.assertEqual(s, "foofoo")
134        s *= -1
135        self.assertEqual(s, "")
136
137def test_main():
138    with warnings.catch_warnings():
139        warnings.filterwarnings("ignore", ".*MutableString",
140                                DeprecationWarning)
141        test_support.run_unittest(UserStringTest, MutableStringTest)
142
143if __name__ == "__main__":
144    test_main()