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 

     5 import string

     6 from test import test_support, string_tests

     7 from UserString import UserString, MutableString

     8 import warnings

     9 

    10 class 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 

    46 class 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 

   137 def test_main():

   138     with warnings.catch_warnings():

   139         warnings.filterwarnings("ignore", ".*MutableString",

   140                                 DeprecationWarning)

   141         test_support.run_unittest(UserStringTest, MutableStringTest)

   142 

   143 if __name__ == "__main__":

   144     test_main()