EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_locale.py

from test.test_support import run_unittest, verbose\r
import unittest\r
import locale\r
import sys\r
import codecs\r
\r
\r
enUS_locale = None\r
\r
def get_enUS_locale():\r
    global enUS_locale\r
    if sys.platform == 'darwin':\r
        import os\r
        tlocs = ("en_US.UTF-8", "en_US.ISO8859-1", "en_US")\r
        if int(os.uname()[2].split('.')[0]) < 10:\r
            # The locale test work fine on OSX 10.6, I (ronaldoussoren)\r
            # haven't had time yet to verify if tests work on OSX 10.5\r
            # (10.4 is known to be bad)\r
            raise unittest.SkipTest("Locale support on MacOSX is minimal")\r
    if sys.platform.startswith("win"):\r
        tlocs = ("En", "English")\r
    else:\r
        tlocs = ("en_US.UTF-8", "en_US.US-ASCII", "en_US")\r
    oldlocale = locale.setlocale(locale.LC_NUMERIC)\r
    for tloc in tlocs:\r
        try:\r
            locale.setlocale(locale.LC_NUMERIC, tloc)\r
        except locale.Error:\r
            continue\r
        break\r
    else:\r
        raise unittest.SkipTest(\r
            "Test locale not supported (tried %s)" % (', '.join(tlocs)))\r
    enUS_locale = tloc\r
    locale.setlocale(locale.LC_NUMERIC, oldlocale)\r
\r
\r
class BaseLocalizedTest(unittest.TestCase):\r
    #\r
    # Base class for tests using a real locale\r
    #\r
\r
    def setUp(self):\r
        self.oldlocale = locale.setlocale(self.locale_type)\r
        locale.setlocale(self.locale_type, enUS_locale)\r
        if verbose:\r
            print "testing with \"%s\"..." % enUS_locale,\r
\r
    def tearDown(self):\r
        locale.setlocale(self.locale_type, self.oldlocale)\r
\r
\r
class BaseCookedTest(unittest.TestCase):\r
    #\r
    # Base class for tests using cooked localeconv() values\r
    #\r
\r
    def setUp(self):\r
        locale._override_localeconv = self.cooked_values\r
\r
    def tearDown(self):\r
        locale._override_localeconv = {}\r
\r
\r
class CCookedTest(BaseCookedTest):\r
    # A cooked "C" locale\r
\r
    cooked_values = {\r
        'currency_symbol': '',\r
        'decimal_point': '.',\r
        'frac_digits': 127,\r
        'grouping': [],\r
        'int_curr_symbol': '',\r
        'int_frac_digits': 127,\r
        'mon_decimal_point': '',\r
        'mon_grouping': [],\r
        'mon_thousands_sep': '',\r
        'n_cs_precedes': 127,\r
        'n_sep_by_space': 127,\r
        'n_sign_posn': 127,\r
        'negative_sign': '',\r
        'p_cs_precedes': 127,\r
        'p_sep_by_space': 127,\r
        'p_sign_posn': 127,\r
        'positive_sign': '',\r
        'thousands_sep': ''\r
    }\r
\r
class EnUSCookedTest(BaseCookedTest):\r
    # A cooked "en_US" locale\r
\r
    cooked_values = {\r
        'currency_symbol': '$',\r
        'decimal_point': '.',\r
        'frac_digits': 2,\r
        'grouping': [3, 3, 0],\r
        'int_curr_symbol': 'USD ',\r
        'int_frac_digits': 2,\r
        'mon_decimal_point': '.',\r
        'mon_grouping': [3, 3, 0],\r
        'mon_thousands_sep': ',',\r
        'n_cs_precedes': 1,\r
        'n_sep_by_space': 0,\r
        'n_sign_posn': 1,\r
        'negative_sign': '-',\r
        'p_cs_precedes': 1,\r
        'p_sep_by_space': 0,\r
        'p_sign_posn': 1,\r
        'positive_sign': '',\r
        'thousands_sep': ','\r
    }\r
\r
\r
class FrFRCookedTest(BaseCookedTest):\r
    # A cooked "fr_FR" locale with a space character as decimal separator\r
    # and a non-ASCII currency symbol.\r
\r
    cooked_values = {\r
        'currency_symbol': '\xe2\x82\xac',\r
        'decimal_point': ',',\r
        'frac_digits': 2,\r
        'grouping': [3, 3, 0],\r
        'int_curr_symbol': 'EUR ',\r
        'int_frac_digits': 2,\r
        'mon_decimal_point': ',',\r
        'mon_grouping': [3, 3, 0],\r
        'mon_thousands_sep': ' ',\r
        'n_cs_precedes': 0,\r
        'n_sep_by_space': 1,\r
        'n_sign_posn': 1,\r
        'negative_sign': '-',\r
        'p_cs_precedes': 0,\r
        'p_sep_by_space': 1,\r
        'p_sign_posn': 1,\r
        'positive_sign': '',\r
        'thousands_sep': ' '\r
    }\r
\r
\r
class BaseFormattingTest(object):\r
    #\r
    # Utility functions for formatting tests\r
    #\r
\r
    def _test_formatfunc(self, format, value, out, func, **format_opts):\r
        self.assertEqual(\r
            func(format, value, **format_opts), out)\r
\r
    def _test_format(self, format, value, out, **format_opts):\r
        self._test_formatfunc(format, value, out,\r
            func=locale.format, **format_opts)\r
\r
    def _test_format_string(self, format, value, out, **format_opts):\r
        self._test_formatfunc(format, value, out,\r
            func=locale.format_string, **format_opts)\r
\r
    def _test_currency(self, value, out, **format_opts):\r
        self.assertEqual(locale.currency(value, **format_opts), out)\r
\r
\r
class EnUSNumberFormatting(BaseFormattingTest):\r
    # XXX there is a grouping + padding bug when the thousands separator\r
    # is empty but the grouping array contains values (e.g. Solaris 10)\r
\r
    def setUp(self):\r
        self.sep = locale.localeconv()['thousands_sep']\r
\r
    def test_grouping(self):\r
        self._test_format("%f", 1024, grouping=1, out='1%s024.000000' % self.sep)\r
        self._test_format("%f", 102, grouping=1, out='102.000000')\r
        self._test_format("%f", -42, grouping=1, out='-42.000000')\r
        self._test_format("%+f", -42, grouping=1, out='-42.000000')\r
\r
    def test_grouping_and_padding(self):\r
        self._test_format("%20.f", -42, grouping=1, out='-42'.rjust(20))\r
        if self.sep:\r
            self._test_format("%+10.f", -4200, grouping=1,\r
                out=('-4%s200' % self.sep).rjust(10))\r
            self._test_format("%-10.f", -4200, grouping=1,\r
                out=('-4%s200' % self.sep).ljust(10))\r
\r
    def test_integer_grouping(self):\r
        self._test_format("%d", 4200, grouping=True, out='4%s200' % self.sep)\r
        self._test_format("%+d", 4200, grouping=True, out='+4%s200' % self.sep)\r
        self._test_format("%+d", -4200, grouping=True, out='-4%s200' % self.sep)\r
\r
    def test_integer_grouping_and_padding(self):\r
        self._test_format("%10d", 4200, grouping=True,\r
            out=('4%s200' % self.sep).rjust(10))\r
        self._test_format("%-10d", -4200, grouping=True,\r
            out=('-4%s200' % self.sep).ljust(10))\r
\r
    def test_simple(self):\r
        self._test_format("%f", 1024, grouping=0, out='1024.000000')\r
        self._test_format("%f", 102, grouping=0, out='102.000000')\r
        self._test_format("%f", -42, grouping=0, out='-42.000000')\r
        self._test_format("%+f", -42, grouping=0, out='-42.000000')\r
\r
    def test_padding(self):\r
        self._test_format("%20.f", -42, grouping=0, out='-42'.rjust(20))\r
        self._test_format("%+10.f", -4200, grouping=0, out='-4200'.rjust(10))\r
        self._test_format("%-10.f", 4200, grouping=0, out='4200'.ljust(10))\r
\r
    def test_complex_formatting(self):\r
        # Spaces in formatting string\r
        self._test_format_string("One million is %i", 1000000, grouping=1,\r
            out='One million is 1%s000%s000' % (self.sep, self.sep))\r
        self._test_format_string("One  million is %i", 1000000, grouping=1,\r
            out='One  million is 1%s000%s000' % (self.sep, self.sep))\r
        # Dots in formatting string\r
        self._test_format_string(".%f.", 1000.0, out='.1000.000000.')\r
        # Padding\r
        if self.sep:\r
            self._test_format_string("-->  %10.2f", 4200, grouping=1,\r
                out='-->  ' + ('4%s200.00' % self.sep).rjust(10))\r
        # Asterisk formats\r
        self._test_format_string("%10.*f", (2, 1000), grouping=0,\r
            out='1000.00'.rjust(10))\r
        if self.sep:\r
            self._test_format_string("%*.*f", (10, 2, 1000), grouping=1,\r
                out=('1%s000.00' % self.sep).rjust(10))\r
        # Test more-in-one\r
        if self.sep:\r
            self._test_format_string("int %i float %.2f str %s",\r
                (1000, 1000.0, 'str'), grouping=1,\r
                out='int 1%s000 float 1%s000.00 str str' %\r
                (self.sep, self.sep))\r
\r
\r
class TestFormatPatternArg(unittest.TestCase):\r
    # Test handling of pattern argument of format\r
\r
    def test_onlyOnePattern(self):\r
        # Issue 2522: accept exactly one % pattern, and no extra chars.\r
        self.assertRaises(ValueError, locale.format, "%f\n", 'foo')\r
        self.assertRaises(ValueError, locale.format, "%f\r", 'foo')\r
        self.assertRaises(ValueError, locale.format, "%f\r\n", 'foo')\r
        self.assertRaises(ValueError, locale.format, " %f", 'foo')\r
        self.assertRaises(ValueError, locale.format, "%fg", 'foo')\r
        self.assertRaises(ValueError, locale.format, "%^g", 'foo')\r
        self.assertRaises(ValueError, locale.format, "%f%%", 'foo')\r
\r
\r
class TestLocaleFormatString(unittest.TestCase):\r
    """General tests on locale.format_string"""\r
\r
    def test_percent_escape(self):\r
        self.assertEqual(locale.format_string('%f%%', 1.0), '%f%%' % 1.0)\r
        self.assertEqual(locale.format_string('%d %f%%d', (1, 1.0)),\r
            '%d %f%%d' % (1, 1.0))\r
        self.assertEqual(locale.format_string('%(foo)s %%d', {'foo': 'bar'}),\r
            ('%(foo)s %%d' % {'foo': 'bar'}))\r
\r
    def test_mapping(self):\r
        self.assertEqual(locale.format_string('%(foo)s bing.', {'foo': 'bar'}),\r
            ('%(foo)s bing.' % {'foo': 'bar'}))\r
        self.assertEqual(locale.format_string('%(foo)s', {'foo': 'bar'}),\r
            ('%(foo)s' % {'foo': 'bar'}))\r
\r
\r
\r
class TestNumberFormatting(BaseLocalizedTest, EnUSNumberFormatting):\r
    # Test number formatting with a real English locale.\r
\r
    locale_type = locale.LC_NUMERIC\r
\r
    def setUp(self):\r
        BaseLocalizedTest.setUp(self)\r
        EnUSNumberFormatting.setUp(self)\r
\r
\r
class TestEnUSNumberFormatting(EnUSCookedTest, EnUSNumberFormatting):\r
    # Test number formatting with a cooked "en_US" locale.\r
\r
    def setUp(self):\r
        EnUSCookedTest.setUp(self)\r
        EnUSNumberFormatting.setUp(self)\r
\r
    def test_currency(self):\r
        self._test_currency(50000, "$50000.00")\r
        self._test_currency(50000, "$50,000.00", grouping=True)\r
        self._test_currency(50000, "USD 50,000.00",\r
            grouping=True, international=True)\r
\r
\r
class TestCNumberFormatting(CCookedTest, BaseFormattingTest):\r
    # Test number formatting with a cooked "C" locale.\r
\r
    def test_grouping(self):\r
        self._test_format("%.2f", 12345.67, grouping=True, out='12345.67')\r
\r
    def test_grouping_and_padding(self):\r
        self._test_format("%9.2f", 12345.67, grouping=True, out=' 12345.67')\r
\r
\r
class TestFrFRNumberFormatting(FrFRCookedTest, BaseFormattingTest):\r
    # Test number formatting with a cooked "fr_FR" locale.\r
\r
    def test_decimal_point(self):\r
        self._test_format("%.2f", 12345.67, out='12345,67')\r
\r
    def test_grouping(self):\r
        self._test_format("%.2f", 345.67, grouping=True, out='345,67')\r
        self._test_format("%.2f", 12345.67, grouping=True, out='12 345,67')\r
\r
    def test_grouping_and_padding(self):\r
        self._test_format("%6.2f", 345.67, grouping=True, out='345,67')\r
        self._test_format("%7.2f", 345.67, grouping=True, out=' 345,67')\r
        self._test_format("%8.2f", 12345.67, grouping=True, out='12 345,67')\r
        self._test_format("%9.2f", 12345.67, grouping=True, out='12 345,67')\r
        self._test_format("%10.2f", 12345.67, grouping=True, out=' 12 345,67')\r
        self._test_format("%-6.2f", 345.67, grouping=True, out='345,67')\r
        self._test_format("%-7.2f", 345.67, grouping=True, out='345,67 ')\r
        self._test_format("%-8.2f", 12345.67, grouping=True, out='12 345,67')\r
        self._test_format("%-9.2f", 12345.67, grouping=True, out='12 345,67')\r
        self._test_format("%-10.2f", 12345.67, grouping=True, out='12 345,67 ')\r
\r
    def test_integer_grouping(self):\r
        self._test_format("%d", 200, grouping=True, out='200')\r
        self._test_format("%d", 4200, grouping=True, out='4 200')\r
\r
    def test_integer_grouping_and_padding(self):\r
        self._test_format("%4d", 4200, grouping=True, out='4 200')\r
        self._test_format("%5d", 4200, grouping=True, out='4 200')\r
        self._test_format("%10d", 4200, grouping=True, out='4 200'.rjust(10))\r
        self._test_format("%-4d", 4200, grouping=True, out='4 200')\r
        self._test_format("%-5d", 4200, grouping=True, out='4 200')\r
        self._test_format("%-10d", 4200, grouping=True, out='4 200'.ljust(10))\r
\r
    def test_currency(self):\r
        euro = u'\u20ac'.encode('utf-8')\r
        self._test_currency(50000, "50000,00 " + euro)\r
        self._test_currency(50000, "50 000,00 " + euro, grouping=True)\r
        # XXX is the trailing space a bug?\r
        self._test_currency(50000, "50 000,00 EUR ",\r
            grouping=True, international=True)\r
\r
\r
class TestStringMethods(BaseLocalizedTest):\r
    locale_type = locale.LC_CTYPE\r
\r
    if sys.platform != 'sunos5' and not sys.platform.startswith("win"):\r
        # Test BSD Rune locale's bug for isctype functions.\r
\r
        def test_isspace(self):\r
            self.assertEqual('\x20'.isspace(), True)\r
            self.assertEqual('\xa0'.isspace(), False)\r
            self.assertEqual('\xa1'.isspace(), False)\r
\r
        def test_isalpha(self):\r
            self.assertEqual('\xc0'.isalpha(), False)\r
\r
        def test_isalnum(self):\r
            self.assertEqual('\xc0'.isalnum(), False)\r
\r
        def test_isupper(self):\r
            self.assertEqual('\xc0'.isupper(), False)\r
\r
        def test_islower(self):\r
            self.assertEqual('\xc0'.islower(), False)\r
\r
        def test_lower(self):\r
            self.assertEqual('\xcc\x85'.lower(), '\xcc\x85')\r
\r
        def test_upper(self):\r
            self.assertEqual('\xed\x95\xa0'.upper(), '\xed\x95\xa0')\r
\r
        def test_strip(self):\r
            self.assertEqual('\xed\x95\xa0'.strip(), '\xed\x95\xa0')\r
\r
        def test_split(self):\r
            self.assertEqual('\xec\xa0\xbc'.split(), ['\xec\xa0\xbc'])\r
\r
\r
class TestMiscellaneous(unittest.TestCase):\r
    def test_getpreferredencoding(self):\r
        # Invoke getpreferredencoding to make sure it does not cause exceptions.\r
        enc = locale.getpreferredencoding()\r
        if enc:\r
            # If encoding non-empty, make sure it is valid\r
            codecs.lookup(enc)\r
\r
    if hasattr(locale, "strcoll"):\r
        def test_strcoll_3303(self):\r
            # test crasher from bug #3303\r
            self.assertRaises(TypeError, locale.strcoll, u"a", None)\r
\r
    def test_setlocale_category(self):\r
        locale.setlocale(locale.LC_ALL)\r
        locale.setlocale(locale.LC_TIME)\r
        locale.setlocale(locale.LC_CTYPE)\r
        locale.setlocale(locale.LC_COLLATE)\r
        locale.setlocale(locale.LC_MONETARY)\r
        locale.setlocale(locale.LC_NUMERIC)\r
\r
        # crasher from bug #7419\r
        self.assertRaises(locale.Error, locale.setlocale, 12345)\r
\r
\r
def test_main():\r
    tests = [\r
        TestMiscellaneous,\r
        TestFormatPatternArg,\r
        TestLocaleFormatString,\r
        TestEnUSNumberFormatting,\r
        TestCNumberFormatting,\r
        TestFrFRNumberFormatting,\r
    ]\r
    # SkipTest can't be raised inside unittests, handle it manually instead\r
    try:\r
        get_enUS_locale()\r
    except unittest.SkipTest as e:\r
        if verbose:\r
            print "Some tests will be disabled: %s" % e\r
    else:\r
        tests += [TestNumberFormatting, TestStringMethods]\r
    run_unittest(*tests)\r
\r
if __name__ == '__main__':\r
    test_main()\r