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_locale.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  9.4 KB  |  294 lines
  1. from test.test_support import run_unittest, verbose, TestSkipped
  2. import unittest
  3. import locale
  4. import sys
  5. import codecs
  6.  
  7.  
  8. enUS_locale = None
  9.  
  10. def get_enUS_locale():
  11.     global enUS_locale
  12.     if sys.platform == 'darwin':
  13.         raise TestSkipped("Locale support on MacOSX is minimal")
  14.     if sys.platform.startswith("win"):
  15.         tlocs = ("En", "English")
  16.     else:
  17.         tlocs = ("en_US.UTF-8", "en_US.US-ASCII", "en_US")
  18.     oldlocale = locale.setlocale(locale.LC_NUMERIC)
  19.     for tloc in tlocs:
  20.         try:
  21.             locale.setlocale(locale.LC_NUMERIC, tloc)
  22.         except locale.Error:
  23.             continue
  24.         break
  25.     else:
  26.         raise TestSkipped(
  27.             "Test locale not supported (tried %s)" % (', '.join(tlocs)))
  28.     enUS_locale = tloc
  29.     locale.setlocale(locale.LC_NUMERIC, oldlocale)
  30.  
  31.  
  32. class BaseLocalizedTest(unittest.TestCase):
  33.     #
  34.     # Base class for tests using a real locale
  35.     #
  36.  
  37.     def setUp(self):
  38.         self.oldlocale = locale.setlocale(self.locale_type)
  39.         locale.setlocale(self.locale_type, enUS_locale)
  40.         if verbose:
  41.             print "testing with \"%s\"..." % enUS_locale,
  42.  
  43.     def tearDown(self):
  44.         locale.setlocale(self.locale_type, self.oldlocale)
  45.  
  46.  
  47. class BaseCookedTest(unittest.TestCase):
  48.     #
  49.     # Base class for tests using cooked localeconv() values
  50.     #
  51.  
  52.     def setUp(self):
  53.         locale._override_localeconv = self.cooked_values
  54.  
  55.     def tearDown(self):
  56.         locale._override_localeconv = {}
  57.  
  58.  
  59. class CCookedTest(BaseCookedTest):
  60.     # A cooked "C" locale
  61.  
  62.     cooked_values = {
  63.         'currency_symbol': '',
  64.         'decimal_point': '.',
  65.         'frac_digits': 127,
  66.         'grouping': [],
  67.         'int_curr_symbol': '',
  68.         'int_frac_digits': 127,
  69.         'mon_decimal_point': '',
  70.         'mon_grouping': [],
  71.         'mon_thousands_sep': '',
  72.         'n_cs_precedes': 127,
  73.         'n_sep_by_space': 127,
  74.         'n_sign_posn': 127,
  75.         'negative_sign': '',
  76.         'p_cs_precedes': 127,
  77.         'p_sep_by_space': 127,
  78.         'p_sign_posn': 127,
  79.         'positive_sign': '',
  80.         'thousands_sep': ''
  81.     }
  82.  
  83. class EnUSCookedTest(BaseCookedTest):
  84.     # A cooked "en_US" locale
  85.  
  86.     cooked_values = {
  87.         'currency_symbol': '$',
  88.         'decimal_point': '.',
  89.         'frac_digits': 2,
  90.         'grouping': [3, 3, 0],
  91.         'int_curr_symbol': 'USD ',
  92.         'int_frac_digits': 2,
  93.         'mon_decimal_point': '.',
  94.         'mon_grouping': [3, 3, 0],
  95.         'mon_thousands_sep': ',',
  96.         'n_cs_precedes': 1,
  97.         'n_sep_by_space': 0,
  98.         'n_sign_posn': 1,
  99.         'negative_sign': '-',
  100.         'p_cs_precedes': 1,
  101.         'p_sep_by_space': 0,
  102.         'p_sign_posn': 1,
  103.         'positive_sign': '',
  104.         'thousands_sep': ','
  105.     }
  106.  
  107.  
  108. class BaseFormattingTest(object):
  109.     #
  110.     # Utility functions for formatting tests
  111.     #
  112.  
  113.     def _test_formatfunc(self, format, value, out, func, **format_opts):
  114.         self.assertEqual(
  115.             func(format, value, **format_opts), out)
  116.  
  117.     def _test_format(self, format, value, out, **format_opts):
  118.         self._test_formatfunc(format, value, out,
  119.             func=locale.format, **format_opts)
  120.  
  121.     def _test_format_string(self, format, value, out, **format_opts):
  122.         self._test_formatfunc(format, value, out,
  123.             func=locale.format_string, **format_opts)
  124.  
  125.     def _test_currency(self, value, out, **format_opts):
  126.         self.assertEqual(locale.currency(value, **format_opts), out)
  127.  
  128.  
  129. class EnUSNumberFormatting(BaseFormattingTest):
  130.     # XXX there is a grouping + padding bug when the thousands separator
  131.     # is empty but the grouping array contains values (e.g. Solaris 10)
  132.  
  133.     def setUp(self):
  134.         self.sep = locale.localeconv()['thousands_sep']
  135.  
  136.     def test_grouping(self):
  137.         self._test_format("%f", 1024, grouping=1, out='1%s024.000000' % self.sep)
  138.         self._test_format("%f", 102, grouping=1, out='102.000000')
  139.         self._test_format("%f", -42, grouping=1, out='-42.000000')
  140.         self._test_format("%+f", -42, grouping=1, out='-42.000000')
  141.  
  142.     def test_grouping_and_padding(self):
  143.         self._test_format("%20.f", -42, grouping=1, out='-42'.rjust(20))
  144.         if self.sep:
  145.             self._test_format("%+10.f", -4200, grouping=1,
  146.                 out=('-4%s200' % self.sep).rjust(10))
  147.             self._test_format("%-10.f", -4200, grouping=1,
  148.                 out=('-4%s200' % self.sep).ljust(10))
  149.  
  150.     def test_integer_grouping(self):
  151.         self._test_format("%d", 4200, grouping=True, out='4%s200' % self.sep)
  152.         self._test_format("%+d", 4200, grouping=True, out='+4%s200' % self.sep)
  153.         self._test_format("%+d", -4200, grouping=True, out='-4%s200' % self.sep)
  154.  
  155.     def test_simple(self):
  156.         self._test_format("%f", 1024, grouping=0, out='1024.000000')
  157.         self._test_format("%f", 102, grouping=0, out='102.000000')
  158.         self._test_format("%f", -42, grouping=0, out='-42.000000')
  159.         self._test_format("%+f", -42, grouping=0, out='-42.000000')
  160.  
  161.     def test_padding(self):
  162.         self._test_format("%20.f", -42, grouping=0, out='-42'.rjust(20))
  163.         self._test_format("%+10.f", -4200, grouping=0, out='-4200'.rjust(10))
  164.         self._test_format("%-10.f", 4200, grouping=0, out='4200'.ljust(10))
  165.  
  166.     def test_complex_formatting(self):
  167.         # Spaces in formatting string
  168.         self._test_format_string("One million is %i", 1000000, grouping=1,
  169.             out='One million is 1%s000%s000' % (self.sep, self.sep))
  170.         self._test_format_string("One  million is %i", 1000000, grouping=1,
  171.             out='One  million is 1%s000%s000' % (self.sep, self.sep))
  172.         # Dots in formatting string
  173.         self._test_format_string(".%f.", 1000.0, out='.1000.000000.')
  174.         # Padding
  175.         if self.sep:
  176.             self._test_format_string("-->  %10.2f", 4200, grouping=1,
  177.                 out='-->  ' + ('4%s200.00' % self.sep).rjust(10))
  178.         # Asterisk formats
  179.         self._test_format_string("%10.*f", (2, 1000), grouping=0,
  180.             out='1000.00'.rjust(10))
  181.         if self.sep:
  182.             self._test_format_string("%*.*f", (10, 2, 1000), grouping=1,
  183.                 out=('1%s000.00' % self.sep).rjust(10))
  184.         # Test more-in-one
  185.         if self.sep:
  186.             self._test_format_string("int %i float %.2f str %s",
  187.                 (1000, 1000.0, 'str'), grouping=1,
  188.                 out='int 1%s000 float 1%s000.00 str str' %
  189.                 (self.sep, self.sep))
  190.  
  191.  
  192. class TestNumberFormatting(BaseLocalizedTest, EnUSNumberFormatting):
  193.     # Test number formatting with a real English locale.
  194.  
  195.     locale_type = locale.LC_NUMERIC
  196.  
  197.     def setUp(self):
  198.         BaseLocalizedTest.setUp(self)
  199.         EnUSNumberFormatting.setUp(self)
  200.  
  201.  
  202. class TestEnUSNumberFormatting(EnUSCookedTest, EnUSNumberFormatting):
  203.     # Test number formatting with a cooked "en_US" locale.
  204.  
  205.     def setUp(self):
  206.         EnUSCookedTest.setUp(self)
  207.         EnUSNumberFormatting.setUp(self)
  208.  
  209.     def test_currency(self):
  210.         self._test_currency(50000, "$50000.00")
  211.         self._test_currency(50000, "$50,000.00", grouping=True)
  212.         self._test_currency(50000, "USD 50,000.00",
  213.             grouping=True, international=True)
  214.  
  215.  
  216. class TestCNumberFormatting(CCookedTest, BaseFormattingTest):
  217.     # Test number formatting with a cooked "C" locale.
  218.  
  219.     def test_grouping(self):
  220.         self._test_format("%.2f", 12345.67, grouping=True, out='12345.67')
  221.  
  222.     def test_grouping_and_padding(self):
  223.         self._test_format("%9.2f", 12345.67, grouping=True, out=' 12345.67')
  224.  
  225.  
  226. class TestStringMethods(BaseLocalizedTest):
  227.     locale_type = locale.LC_CTYPE
  228.  
  229.     if sys.platform != 'sunos5' and not sys.platform.startswith("win"):
  230.         # Test BSD Rune locale's bug for isctype functions.
  231.  
  232.         def test_isspace(self):
  233.             self.assertEqual('\x20'.isspace(), True)
  234.             self.assertEqual('\xa0'.isspace(), False)
  235.             self.assertEqual('\xa1'.isspace(), False)
  236.  
  237.         def test_isalpha(self):
  238.             self.assertEqual('\xc0'.isalpha(), False)
  239.  
  240.         def test_isalnum(self):
  241.             self.assertEqual('\xc0'.isalnum(), False)
  242.  
  243.         def test_isupper(self):
  244.             self.assertEqual('\xc0'.isupper(), False)
  245.  
  246.         def test_islower(self):
  247.             self.assertEqual('\xc0'.islower(), False)
  248.  
  249.         def test_lower(self):
  250.             self.assertEqual('\xcc\x85'.lower(), '\xcc\x85')
  251.  
  252.         def test_upper(self):
  253.             self.assertEqual('\xed\x95\xa0'.upper(), '\xed\x95\xa0')
  254.  
  255.         def test_strip(self):
  256.             self.assertEqual('\xed\x95\xa0'.strip(), '\xed\x95\xa0')
  257.  
  258.         def test_split(self):
  259.             self.assertEqual('\xec\xa0\xbc'.split(), ['\xec\xa0\xbc'])
  260.  
  261.  
  262. class TestMiscellaneous(unittest.TestCase):
  263.     def test_getpreferredencoding(self):
  264.         # Invoke getpreferredencoding to make sure it does not cause exceptions.
  265.         enc = locale.getpreferredencoding()
  266.         if enc:
  267.             # If encoding non-empty, make sure it is valid
  268.             codecs.lookup(enc)
  269.  
  270.     if hasattr(locale, "strcoll"):
  271.         def test_strcoll_3303(self):
  272.             # test crasher from bug #3303
  273.             self.assertRaises(TypeError, locale.strcoll, u"a", None)
  274.  
  275.  
  276. def test_main():
  277.     tests = [
  278.         TestMiscellaneous,
  279.         TestEnUSNumberFormatting,
  280.         TestCNumberFormatting
  281.     ]
  282.     # TestSkipped can't be raised inside unittests, handle it manually instead
  283.     try:
  284.         get_enUS_locale()
  285.     except TestSkipped as e:
  286.         if verbose:
  287.             print "Some tests will be disabled: %s" % e
  288.     else:
  289.         tests += [TestNumberFormatting, TestStringMethods]
  290.     run_unittest(*tests)
  291.  
  292. if __name__ == '__main__':
  293.     test_main()
  294.