home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_userstring.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  4.6 KB  |  145 lines
  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()
  145.