[blivet:master+? 9/9] Add a number of new tests.

mulhern amulhern at redhat.com
Thu Oct 23 17:57:09 UTC 2014


---
 tests/size_test.py | 123 +++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 111 insertions(+), 12 deletions(-)

diff --git a/tests/size_test.py b/tests/size_test.py
index a624aa8..909a5c8 100644
--- a/tests/size_test.py
+++ b/tests/size_test.py
@@ -21,19 +21,34 @@
 #
 # Red Hat Author(s): David Cantrell <dcantrell at redhat.com>
 
+import locale
+import os
 import unittest
 
 from decimal import Decimal
 
 import six
 
+from blivet.i18n import _
 from blivet.errors import SizePlacesError
+from blivet import size
 from blivet.size import Size, _EMPTY_PREFIX, _BINARY_PREFIXES, _DECIMAL_PREFIXES
 
 if six.PY3:
     long = int # pylint: disable=redefined-builtin
 
 class SizeTestCase(unittest.TestCase):
+
+    def __init__(self, methodName='runTest'):
+        super(SizeTestCase, self).__init__(methodName=methodName)
+
+        # es_ES uses latin-characters but a comma as the radix separator
+        # kk_KZ uses non-latin characters and is case-sensitive
+        # ml_IN uses a lot of non-letter modifier characters
+        # fa_IR uses non-ascii digits, or would if python supported that, but
+        #       you know, just in case
+        self.TEST_LANGS = ["es_ES.UTF-8", "kk_KZ.UTF-8", "ml_IN.UTF-8", "fa_IR.UTF-8"]
+
     def testExceptions(self):
         zero = Size(0)
         self.assertEqual(zero, 0.0)
@@ -158,6 +173,25 @@ class SizeTestCase(unittest.TestCase):
         s = Size(0x10000000000000)
         self.assertEquals(s.humanReadable(max_places=2), "4 PiB")
 
+    def testHumanReadableTranslation(self):
+        saved_lang = os.environ.get('LANG', None)
+
+
+        s = Size("56.19 MiB")
+        size_str = s.humanReadable()
+        for lang in self.TEST_LANGS:
+
+            # Python does not support characters in this language
+            if lang == "fa_IR.UTF-8":
+                continue
+
+            os.environ['LANG'] = lang
+            locale.setlocale(locale.LC_ALL, '')
+            self.assertNotEqual(s.humanReadable(), size_str)
+
+        os.environ['LANG'] = saved_lang
+        locale.setlocale(locale.LC_ALL, '')
+
     def testMinValue(self):
         s = Size("9 MiB")
         self.assertEquals(s.humanReadable(), "9 MiB")
@@ -170,6 +204,7 @@ class SizeTestCase(unittest.TestCase):
 
     def testConvertToPrecision(self):
         s = Size(1835008)
+        self.assertEquals(s.convertTo(spec=""), 1835008)
         self.assertEquals(s.convertTo(spec="b"), 1835008)
         self.assertEquals(s.convertTo(spec="KiB"), 1792)
         self.assertEquals(s.convertTo(spec="MiB"), 1.75)
@@ -185,21 +220,10 @@ class SizeTestCase(unittest.TestCase):
         self.assertEquals(Size("%s KiB" % (1/1023.0,)), Size(1))
 
     def testTranslated(self):
-        import locale
-        import os
-        from blivet.i18n import _
-
         saved_lang = os.environ.get('LANG', None)
 
-        # es_ES uses latin-characters but a comma as the radix separator
-        # kk_KZ uses non-latin characters and is case-sensitive
-        # te_IN uses a lot of non-letter modifier characters
-        # fa_IR uses non-ascii digits, or would if python supported that, but
-        #       you know, just in case
-        test_langs = ["es_ES.UTF-8", "kk_KZ.UTF-8", "ml_IN.UTF-8", "fa_IR.UTF-8"]
-
         s = Size("56.19 MiB")
-        for lang in test_langs:
+        for lang in  self.TEST_LANGS:
             os.environ['LANG'] = lang
             locale.setlocale(locale.LC_ALL, '')
 
@@ -227,5 +251,80 @@ class SizeTestCase(unittest.TestCase):
         os.environ['LANG'] = saved_lang
         locale.setlocale(locale.LC_ALL, '')
 
+    def testParseSpec(self):
+        """ Tests for _parseSpec(). """
+        saved_lang = os.environ.get('LANG', None)
+
+        for lang in  self.TEST_LANGS:
+            os.environ['LANG'] = lang
+            locale.setlocale(locale.LC_ALL, '')
+
+            # Test parsing English spec in foreign locales
+            self.assertEqual(size._parseSpec("1 kibibytes"), Decimal(1024))
+            self.assertEqual(size._parseSpec("2 kibibyte"), Decimal(2048))
+            self.assertEqual(size._parseSpec("2 kilobyte"), Decimal(2000))
+            self.assertEqual(size._parseSpec("2 kilobytes"), Decimal(2000))
+            self.assertEqual(size._parseSpec("2 KB"), Decimal(2000))
+            self.assertEqual(size._parseSpec("2 K"), Decimal(2000))
+            self.assertEqual(size._parseSpec("2 Ki"), Decimal(2048))
+
+            # Test parsing foreign spec
+            self.assertEqual(size._parseSpec("1 %s%s" % (_("kibi"), _("bytes"))), Decimal(1024))
+
+        os.environ['LANG'] = saved_lang
+        locale.setlocale(locale.LC_ALL, '')
+
+    def testMakeSpecs(self):
+        """ Tests for _makeSpecs(). """
+        bytes_result = set(['byte', 'bytes', 'b', ''])
+        mi_result = set(['mebibyte', 'mebibytes', 'mib', 'mi'])
+
+        saved_lang = os.environ.get('LANG', None)
+
+        for lang in  self.TEST_LANGS:
+            os.environ['LANG'] = lang
+            locale.setlocale(locale.LC_ALL, '')
+
+            # untranslated specs
+            self.assertEqual(
+               set(size._makeSpecs(b"", b"", False)),
+               bytes_result
+            )
+            self.assertEqual(
+               set(size._makeSpecs(b"mebi", b"Mi", False)),
+               mi_result
+            )
+
+            # translated specs
+            self.assertNotEqual(set(size._makeSpecs(b"", b"", False)), set())
+            self.assertNotEqual(set(size._makeSpecs(b"mebi", b"Mi", False)), set())
+
+        os.environ['LANG'] = saved_lang
+        locale.setlocale(locale.LC_ALL, '')
+
+    def testGetSpecifiers(self):
+        """ Tests for getSpecifiers(). """
+        saved_lang = os.environ.get('LANG', None)
+
+        for lang in  self.TEST_LANGS:
+            os.environ['LANG'] = lang
+            locale.setlocale(locale.LC_ALL, '')
+
+            # Test English spec in foreign locales
+            self.assertIsNone(size.getSpecifiers(None))
+            self.assertIsNone(size.getSpecifiers(2))
+            self.assertIn("kb", size.getSpecifiers(1000))
+            self.assertIn("kib", size.getSpecifiers(1024))
+
+        os.environ['LANG'] = saved_lang
+        locale.setlocale(locale.LC_ALL, '')
+
+class UtilityMethodsTestCase(unittest.TestCase):
+
+    def testLowerASCII(self):
+        """ Tests for _lowerASCII. """
+        self.assertEqual(size._lowerASCII(b""), b"")
+        self.assertEqual(size._lowerASCII(b"B"), b"b")
+
 if __name__ == "__main__":
     unittest.main()
-- 
1.9.3



More information about the anaconda-patches mailing list