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.assertEqual(s, "".join(L))
108
109                    del L[start:stop:step]
110                    del s[start:stop:step]
111                    self.assertEqual(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.assertIsInstance(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 has been removed",
140                                DeprecationWarning)
141        warnings.filterwarnings("ignore",
142                                ".*__(get|set|del)slice__ has been removed",
143                                DeprecationWarning)
144        test_support.run_unittest(UserStringTest, MutableStringTest)
145
146if __name__ == "__main__":
147    test_main()
148