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
   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.assertTrue(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()