Home | History | Annotate | Download | only in test 
      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.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 
    137 def 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 
    146 if __name__ == "__main__":
    147     test_main()
    148