qubes-installer-qubes-os/anaconda/tests/pyanaconda_tests/localization_test.py
Marek Marczykowski-Górecki 701ced5ddb anaconda: update to 22.20.13-1
Apply diff anaconda-21.48.21-1..anaconda-22.20.13-1
2016-03-22 02:27:17 +13:00

159 lines
7.6 KiB
Python

#
# Copyright (C) 2013 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
# Public License for more details. You should have received a copy of the
# GNU General Public License along with this program; if not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#
# Red Hat Author(s): Vratislav Podzimek <vpodzime@redhat.com>
#
from pyanaconda import localization
from pyanaconda.iutil import execReadlines
import locale as locale_mod
import unittest
class ParsingTests(unittest.TestCase):
def invalid_langcodes_test(self):
"""Should return None for invalid langcodes."""
# None
parts = localization.parse_langcode(None)
self.assertIsNone(parts)
# nonsense
parts = localization.parse_langcode("*_&!")
self.assertIsNone(parts)
# no language
parts = localization.parse_langcode("_CZ")
self.assertIsNone(parts)
def parsing_test(self):
"""Should correctly parse valid langcodes."""
parts = localization.parse_langcode("cs")
self.assertIn("language", parts)
self.assertEqual(parts["language"], "cs")
parts = localization.parse_langcode("cs_CZ")
self.assertIn("language", parts)
self.assertIn("territory", parts)
self.assertEqual(parts["language"], "cs")
self.assertEqual(parts["territory"], "CZ")
parts = localization.parse_langcode("cs_CZ.UTF-8")
self.assertIn("language", parts)
self.assertIn("territory", parts)
self.assertIn("encoding", parts)
self.assertEqual(parts["language"], "cs")
self.assertEqual(parts["territory"], "CZ")
self.assertEqual(parts["encoding"], "UTF-8")
parts = localization.parse_langcode("cs_CZ.UTF-8@latin")
self.assertIn("language", parts)
self.assertIn("territory", parts)
self.assertIn("encoding", parts)
self.assertIn("script", parts)
self.assertEqual(parts["language"], "cs")
self.assertEqual(parts["territory"], "CZ")
self.assertEqual(parts["encoding"], "UTF-8")
self.assertEqual(parts["script"], "latin")
parts = localization.parse_langcode("cs.UTF-8@latin")
self.assertIn("language", parts)
self.assertIn("encoding", parts)
self.assertIn("script", parts)
self.assertEqual(parts["language"], "cs")
self.assertEqual(parts["encoding"], "UTF-8")
self.assertEqual(parts["script"], "latin")
parts = localization.parse_langcode("cs_CZ@latin")
self.assertIn("language", parts)
self.assertIn("territory", parts)
self.assertIn("script", parts)
self.assertEqual(parts["language"], "cs")
self.assertEqual(parts["territory"], "CZ")
self.assertEqual(parts["script"], "latin")
class LangcodeLocaleMatchingTests(unittest.TestCase):
def langcode_matches_locale_test(self):
"""Langcode-locale matching should work as expected."""
# should match
self.assertTrue(localization.langcode_matches_locale("sr", "sr"))
self.assertTrue(localization.langcode_matches_locale("sr", "sr_RS"))
self.assertTrue(localization.langcode_matches_locale("sr", "sr_RS.UTF-8"))
self.assertTrue(localization.langcode_matches_locale("sr", "sr_RS.UTF-8@latin"))
self.assertTrue(localization.langcode_matches_locale("sr_RS", "sr_RS"))
self.assertTrue(localization.langcode_matches_locale("sr_RS", "sr_RS.UTF-8"))
self.assertTrue(localization.langcode_matches_locale("sr_RS", "sr_RS.UTF-8@latin"))
self.assertTrue(localization.langcode_matches_locale("sr_RS.UTF-8", "sr_RS.UTF-8"))
self.assertTrue(localization.langcode_matches_locale("sr_RS.UTF-8", "sr_RS.UTF-8@latin"))
self.assertTrue(localization.langcode_matches_locale("sr_RS.UTF-8@latin", "sr_RS.UTF-8@latin"))
# missing language, shouldn't match
self.assertFalse(localization.langcode_matches_locale("", "sr"))
self.assertFalse(localization.langcode_matches_locale("sr", ""))
self.assertFalse(localization.langcode_matches_locale("sr", None))
self.assertFalse(localization.langcode_matches_locale(None, "sr"))
# missing items in the locale, shouldn't match
self.assertFalse(localization.langcode_matches_locale("sr_RS", "sr"))
self.assertFalse(localization.langcode_matches_locale("sr_RS.UTF-8", "sr_RS"))
self.assertFalse(localization.langcode_matches_locale("sr.UTF-8", "sr_RS"))
self.assertFalse(localization.langcode_matches_locale("sr_RS.UTF-8", "sr.UTF-8"))
self.assertFalse(localization.langcode_matches_locale("sr_RS.UTF-8@latin", "sr_RS"))
self.assertFalse(localization.langcode_matches_locale("sr_RS@latin", "sr_RS"))
self.assertFalse(localization.langcode_matches_locale("sr.UTF-8@latin", "sr_RS.UTF-8"))
self.assertFalse(localization.langcode_matches_locale("sr@latin", "sr_RS"))
# different parts, shouldn't match
self.assertFalse(localization.langcode_matches_locale("sr", "en"))
self.assertFalse(localization.langcode_matches_locale("de_CH", "fr_CH"))
self.assertFalse(localization.langcode_matches_locale("sr_RS", "sr_ME"))
self.assertFalse(localization.langcode_matches_locale("sr_RS@latin", "sr_RS@cyrilic"))
self.assertFalse(localization.langcode_matches_locale("sr_RS@latin", "sr_ME@latin"))
def find_best_locale_match_test(self):
"""Finding best locale matches should work as expected."""
# can find best matches
self.assertEqual(localization.find_best_locale_match("cs_CZ", ["cs", "cs_CZ", "en", "en_US"]), "cs_CZ")
self.assertEqual(localization.find_best_locale_match("cs", ["cs_CZ", "cs", "en", "en_US"]), "cs")
self.assertEqual(localization.find_best_locale_match("pt_BR", ["pt", "pt_BR"]), "pt_BR")
self.assertEqual(localization.find_best_locale_match("pt_BR", ["pt", "pt_BR", "pt_PT"]), "pt_BR")
self.assertEqual(localization.find_best_locale_match("cs_CZ.UTF-8", ["cs", "cs_CZ", "cs_CZ.UTF-8"]),
"cs_CZ.UTF-8")
self.assertEqual(localization.find_best_locale_match("cs_CZ.UTF-8@latin",
["cs", "cs_CZ@latin", "cs_CZ.UTF-8"]), "cs_CZ@latin")
# no matches
self.assertIsNone(localization.find_best_locale_match("pt_BR", ["en_BR", "en"]))
self.assertIsNone(localization.find_best_locale_match("cs_CZ.UTF-8", ["en", "en.UTF-8"]))
def resolve_date_format_test(self):
"""All locales' date formats should be properly resolved."""
locales = (line.strip() for line in execReadlines("locale", ["-a"]))
for locale in locales:
try:
locale_mod.setlocale(locale_mod.LC_ALL, locale)
except locale_mod.Error:
# cannot set locale (a bug in the locale module?)
continue
order = localization.resolve_date_format(1, 2, 3, fail_safe=False)[0]
for i in (1, 2, 3):
self.assertIn(i, order)