PageRenderTime 764ms CodeModel.GetById 262ms app.highlight 299ms RepoModel.GetById 197ms app.codeStats 0ms

/Lib/test/test_locale.py

http://unladen-swallow.googlecode.com/
Python | 369 lines | 329 code | 29 blank | 11 comment | 10 complexity | bdeacdb0c43de8d840cac774076b885c MD5 | raw file
  1from test.test_support import run_unittest, verbose, TestSkipped
  2import unittest
  3import locale
  4import sys
  5import codecs
  6
  7
  8enUS_locale = None
  9
 10def 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
 32class 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
 47class 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
 59class 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
 83class 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
108class FrFRCookedTest(BaseCookedTest):
109    # A cooked "fr_FR" locale with a space character as decimal separator
110    # and a non-ASCII currency symbol.
111
112    cooked_values = {
113        'currency_symbol': '\xe2\x82\xac',
114        'decimal_point': ',',
115        'frac_digits': 2,
116        'grouping': [3, 3, 0],
117        'int_curr_symbol': 'EUR ',
118        'int_frac_digits': 2,
119        'mon_decimal_point': ',',
120        'mon_grouping': [3, 3, 0],
121        'mon_thousands_sep': ' ',
122        'n_cs_precedes': 0,
123        'n_sep_by_space': 1,
124        'n_sign_posn': 1,
125        'negative_sign': '-',
126        'p_cs_precedes': 0,
127        'p_sep_by_space': 1,
128        'p_sign_posn': 1,
129        'positive_sign': '',
130        'thousands_sep': ' '
131    }
132
133
134class BaseFormattingTest(object):
135    #
136    # Utility functions for formatting tests
137    #
138
139    def _test_formatfunc(self, format, value, out, func, **format_opts):
140        self.assertEqual(
141            func(format, value, **format_opts), out)
142
143    def _test_format(self, format, value, out, **format_opts):
144        self._test_formatfunc(format, value, out,
145            func=locale.format, **format_opts)
146
147    def _test_format_string(self, format, value, out, **format_opts):
148        self._test_formatfunc(format, value, out,
149            func=locale.format_string, **format_opts)
150
151    def _test_currency(self, value, out, **format_opts):
152        self.assertEqual(locale.currency(value, **format_opts), out)
153
154
155class EnUSNumberFormatting(BaseFormattingTest):
156    # XXX there is a grouping + padding bug when the thousands separator
157    # is empty but the grouping array contains values (e.g. Solaris 10)
158
159    def setUp(self):
160        self.sep = locale.localeconv()['thousands_sep']
161
162    def test_grouping(self):
163        self._test_format("%f", 1024, grouping=1, out='1%s024.000000' % self.sep)
164        self._test_format("%f", 102, grouping=1, out='102.000000')
165        self._test_format("%f", -42, grouping=1, out='-42.000000')
166        self._test_format("%+f", -42, grouping=1, out='-42.000000')
167
168    def test_grouping_and_padding(self):
169        self._test_format("%20.f", -42, grouping=1, out='-42'.rjust(20))
170        if self.sep:
171            self._test_format("%+10.f", -4200, grouping=1,
172                out=('-4%s200' % self.sep).rjust(10))
173            self._test_format("%-10.f", -4200, grouping=1,
174                out=('-4%s200' % self.sep).ljust(10))
175
176    def test_integer_grouping(self):
177        self._test_format("%d", 4200, grouping=True, out='4%s200' % self.sep)
178        self._test_format("%+d", 4200, grouping=True, out='+4%s200' % self.sep)
179        self._test_format("%+d", -4200, grouping=True, out='-4%s200' % self.sep)
180
181    def test_integer_grouping_and_padding(self):
182        self._test_format("%10d", 4200, grouping=True,
183            out=('4%s200' % self.sep).rjust(10))
184        self._test_format("%-10d", -4200, grouping=True,
185            out=('-4%s200' % self.sep).ljust(10))
186
187    def test_simple(self):
188        self._test_format("%f", 1024, grouping=0, out='1024.000000')
189        self._test_format("%f", 102, grouping=0, out='102.000000')
190        self._test_format("%f", -42, grouping=0, out='-42.000000')
191        self._test_format("%+f", -42, grouping=0, out='-42.000000')
192
193    def test_padding(self):
194        self._test_format("%20.f", -42, grouping=0, out='-42'.rjust(20))
195        self._test_format("%+10.f", -4200, grouping=0, out='-4200'.rjust(10))
196        self._test_format("%-10.f", 4200, grouping=0, out='4200'.ljust(10))
197
198    def test_complex_formatting(self):
199        # Spaces in formatting string
200        self._test_format_string("One million is %i", 1000000, grouping=1,
201            out='One million is 1%s000%s000' % (self.sep, self.sep))
202        self._test_format_string("One  million is %i", 1000000, grouping=1,
203            out='One  million is 1%s000%s000' % (self.sep, self.sep))
204        # Dots in formatting string
205        self._test_format_string(".%f.", 1000.0, out='.1000.000000.')
206        # Padding
207        if self.sep:
208            self._test_format_string("-->  %10.2f", 4200, grouping=1,
209                out='-->  ' + ('4%s200.00' % self.sep).rjust(10))
210        # Asterisk formats
211        self._test_format_string("%10.*f", (2, 1000), grouping=0,
212            out='1000.00'.rjust(10))
213        if self.sep:
214            self._test_format_string("%*.*f", (10, 2, 1000), grouping=1,
215                out=('1%s000.00' % self.sep).rjust(10))
216        # Test more-in-one
217        if self.sep:
218            self._test_format_string("int %i float %.2f str %s",
219                (1000, 1000.0, 'str'), grouping=1,
220                out='int 1%s000 float 1%s000.00 str str' %
221                (self.sep, self.sep))
222
223
224class TestNumberFormatting(BaseLocalizedTest, EnUSNumberFormatting):
225    # Test number formatting with a real English locale.
226
227    locale_type = locale.LC_NUMERIC
228
229    def setUp(self):
230        BaseLocalizedTest.setUp(self)
231        EnUSNumberFormatting.setUp(self)
232
233
234class TestEnUSNumberFormatting(EnUSCookedTest, EnUSNumberFormatting):
235    # Test number formatting with a cooked "en_US" locale.
236
237    def setUp(self):
238        EnUSCookedTest.setUp(self)
239        EnUSNumberFormatting.setUp(self)
240
241    def test_currency(self):
242        self._test_currency(50000, "$50000.00")
243        self._test_currency(50000, "$50,000.00", grouping=True)
244        self._test_currency(50000, "USD 50,000.00",
245            grouping=True, international=True)
246
247
248class TestCNumberFormatting(CCookedTest, BaseFormattingTest):
249    # Test number formatting with a cooked "C" locale.
250
251    def test_grouping(self):
252        self._test_format("%.2f", 12345.67, grouping=True, out='12345.67')
253
254    def test_grouping_and_padding(self):
255        self._test_format("%9.2f", 12345.67, grouping=True, out=' 12345.67')
256
257
258class TestFrFRNumberFormatting(FrFRCookedTest, BaseFormattingTest):
259    # Test number formatting with a cooked "fr_FR" locale.
260
261    def test_decimal_point(self):
262        self._test_format("%.2f", 12345.67, out='12345,67')
263
264    def test_grouping(self):
265        self._test_format("%.2f", 345.67, grouping=True, out='345,67')
266        self._test_format("%.2f", 12345.67, grouping=True, out='12 345,67')
267
268    def test_grouping_and_padding(self):
269        self._test_format("%6.2f", 345.67, grouping=True, out='345,67')
270        self._test_format("%7.2f", 345.67, grouping=True, out=' 345,67')
271        self._test_format("%8.2f", 12345.67, grouping=True, out='12 345,67')
272        self._test_format("%9.2f", 12345.67, grouping=True, out='12 345,67')
273        self._test_format("%10.2f", 12345.67, grouping=True, out=' 12 345,67')
274        self._test_format("%-6.2f", 345.67, grouping=True, out='345,67')
275        self._test_format("%-7.2f", 345.67, grouping=True, out='345,67 ')
276        self._test_format("%-8.2f", 12345.67, grouping=True, out='12 345,67')
277        self._test_format("%-9.2f", 12345.67, grouping=True, out='12 345,67')
278        self._test_format("%-10.2f", 12345.67, grouping=True, out='12 345,67 ')
279
280    def test_integer_grouping(self):
281        self._test_format("%d", 200, grouping=True, out='200')
282        self._test_format("%d", 4200, grouping=True, out='4 200')
283
284    def test_integer_grouping_and_padding(self):
285        self._test_format("%4d", 4200, grouping=True, out='4 200')
286        self._test_format("%5d", 4200, grouping=True, out='4 200')
287        self._test_format("%10d", 4200, grouping=True, out='4 200'.rjust(10))
288        self._test_format("%-4d", 4200, grouping=True, out='4 200')
289        self._test_format("%-5d", 4200, grouping=True, out='4 200')
290        self._test_format("%-10d", 4200, grouping=True, out='4 200'.ljust(10))
291
292    def test_currency(self):
293        euro = u'\u20ac'.encode('utf-8')
294        self._test_currency(50000, "50000,00 " + euro)
295        self._test_currency(50000, "50 000,00 " + euro, grouping=True)
296        # XXX is the trailing space a bug?
297        self._test_currency(50000, "50 000,00 EUR ",
298            grouping=True, international=True)
299
300
301class TestStringMethods(BaseLocalizedTest):
302    locale_type = locale.LC_CTYPE
303
304    if sys.platform != 'sunos5' and not sys.platform.startswith("win"):
305        # Test BSD Rune locale's bug for isctype functions.
306
307        def test_isspace(self):
308            self.assertEqual('\x20'.isspace(), True)
309            self.assertEqual('\xa0'.isspace(), False)
310            self.assertEqual('\xa1'.isspace(), False)
311
312        def test_isalpha(self):
313            self.assertEqual('\xc0'.isalpha(), False)
314
315        def test_isalnum(self):
316            self.assertEqual('\xc0'.isalnum(), False)
317
318        def test_isupper(self):
319            self.assertEqual('\xc0'.isupper(), False)
320
321        def test_islower(self):
322            self.assertEqual('\xc0'.islower(), False)
323
324        def test_lower(self):
325            self.assertEqual('\xcc\x85'.lower(), '\xcc\x85')
326
327        def test_upper(self):
328            self.assertEqual('\xed\x95\xa0'.upper(), '\xed\x95\xa0')
329
330        def test_strip(self):
331            self.assertEqual('\xed\x95\xa0'.strip(), '\xed\x95\xa0')
332
333        def test_split(self):
334            self.assertEqual('\xec\xa0\xbc'.split(), ['\xec\xa0\xbc'])
335
336
337class TestMiscellaneous(unittest.TestCase):
338    def test_getpreferredencoding(self):
339        # Invoke getpreferredencoding to make sure it does not cause exceptions.
340        enc = locale.getpreferredencoding()
341        if enc:
342            # If encoding non-empty, make sure it is valid
343            codecs.lookup(enc)
344
345    if hasattr(locale, "strcoll"):
346        def test_strcoll_3303(self):
347            # test crasher from bug #3303
348            self.assertRaises(TypeError, locale.strcoll, u"a", None)
349
350
351def test_main():
352    tests = [
353        TestMiscellaneous,
354        TestEnUSNumberFormatting,
355        TestCNumberFormatting,
356        TestFrFRNumberFormatting,
357    ]
358    # TestSkipped can't be raised inside unittests, handle it manually instead
359    try:
360        get_enUS_locale()
361    except TestSkipped as e:
362        if verbose:
363            print "Some tests will be disabled: %s" % e
364    else:
365        tests += [TestNumberFormatting, TestStringMethods]
366    run_unittest(*tests)
367
368if __name__ == '__main__':
369    test_main()