diff options
Diffstat (limited to 'src/zope/i18n/tests')
| -rw-r--r-- | src/zope/i18n/tests/test.py | 19 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_compile.py | 10 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_formats.py | 1684 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_gettextmessagecatalog.py | 3 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_imessagecatalog.py | 4 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_itranslationdomain.py | 47 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_negotiator.py | 25 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_plurals.py | 408 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_simpletranslationdomain.py | 4 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_testmessagecatalog.py | 8 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_translationdomain.py | 141 | ||||
| -rw-r--r-- | src/zope/i18n/tests/test_zcml.py | 118 | ||||
| -rw-r--r-- | src/zope/i18n/tests/testi18nawareobject.py | 8 |
13 files changed, 1541 insertions, 938 deletions
diff --git a/src/zope/i18n/tests/test.py b/src/zope/i18n/tests/test.py index 4fb4f4c..64fdbeb 100644 --- a/src/zope/i18n/tests/test.py +++ b/src/zope/i18n/tests/test.py @@ -22,18 +22,23 @@ from zope.i18n.testing import unicode_checker def test_suite(): options = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS + def suite(name): return doctest.DocTestSuite( name, - setUp=setUp, tearDown=tearDown, + setUp=setUp, + tearDown=tearDown, optionflags=options, - checker=unicode_checker) + checker=unicode_checker, + ) - return unittest.TestSuite([ - suite('zope.i18n'), - suite("zope.i18n.config"), - suite("zope.i18n.testing"), - ]) + return unittest.TestSuite( + [ + suite('zope.i18n'), + suite("zope.i18n.config"), + suite("zope.i18n.testing"), + ] + ) if __name__ == '__main__': diff --git a/src/zope/i18n/tests/test_compile.py b/src/zope/i18n/tests/test_compile.py index d82c3e7..214c240 100644 --- a/src/zope/i18n/tests/test_compile.py +++ b/src/zope/i18n/tests/test_compile.py @@ -19,10 +19,8 @@ from zope.testing.loggingsupport import InstalledHandler from zope.i18n import compile -@unittest.skipUnless(compile.HAS_PYTHON_GETTEXT, - "Need python-gettext") +@unittest.skipUnless(compile.HAS_PYTHON_GETTEXT, "Need python-gettext") class TestCompile(unittest.TestCase): - def setUp(self): self.handler = InstalledHandler('zope.i18n') self.addCleanup(self.handler.uninstall) @@ -43,8 +41,7 @@ class TestCompile(unittest.TestCase): compile.compile_mo_file('foo', td) - self.assertIn("Syntax error while compiling", - str(self.handler)) + self.assertIn("Syntax error while compiling", str(self.handler)) def test_po_exists_cannot_write_mo(self): import tempfile @@ -68,5 +65,4 @@ class TestCompile(unittest.TestCase): compile.compile_mo_file('foo', td) - self.assertIn("Error while compiling", - str(self.handler)) + self.assertIn("Error while compiling", str(self.handler)) diff --git a/src/zope/i18n/tests/test_formats.py b/src/zope/i18n/tests/test_formats.py index 83c9129..29de8c9 100644 --- a/src/zope/i18n/tests/test_formats.py +++ b/src/zope/i18n/tests/test_formats.py @@ -34,6 +34,7 @@ from zope.i18n.format import NumberPatternParseError class LocaleStub(object): pass + class LocaleCalendarStub(object): type = u"gregorian" @@ -50,7 +51,7 @@ class LocaleCalendarStub(object): 9: ('September', 'Sep'), 10: ('Oktober', 'Okt'), 11: ('November', 'Nov'), - 12: ('Dezember', 'Dez') + 12: ('Dezember', 'Dez'), } days = { @@ -60,7 +61,7 @@ class LocaleCalendarStub(object): 4: ('Donnerstag', 'Do'), 5: ('Freitag', 'Fr'), 6: ('Samstag', 'Sa'), - 7: ('Sonntag', 'So') + 7: ('Sonntag', 'So'), } am = 'vorm.' @@ -71,7 +72,9 @@ class LocaleCalendarStub(object): week = {'firstDay': 1, 'minDays': 1} def getMonthNames(self): - return [self.months.get(type, (None, None))[0] for type in range(1, 13)] + return [ + self.months.get(type, (None, None))[0] for type in range(1, 13) + ] def getMonthTypeFromName(self, name): for item in self.months.items(): @@ -79,7 +82,9 @@ class LocaleCalendarStub(object): return item[0] def getMonthAbbreviations(self): - return [self.months.get(type, (None, None))[1] for type in range(1, 13)] + return [ + self.months.get(type, (None, None))[1] for type in range(1, 13) + ] def getMonthTypeFromAbbreviation(self, abbr): for item in self.months.items(): @@ -102,94 +107,170 @@ class LocaleCalendarStub(object): class _TestCase(TestCase): # Avoid deprecation warnings in Python 3 by making the preferred # method name available for Python 2. - assertRaisesRegex = getattr(TestCase, 'assertRaisesRegex', TestCase.assertRaisesRegexp) + assertRaisesRegex = getattr( + TestCase, 'assertRaisesRegex', TestCase.assertRaisesRegexp + ) class TestDateTimePatternParser(_TestCase): """Extensive tests for the ICU-based-syntax datetime pattern parser.""" - def testParseSimpleTimePattern(self): - self.assertEqual(parseDateTimePattern('HH'), - [('H', 2)]) - self.assertEqual(parseDateTimePattern('HH:mm'), - [('H', 2), ':', ('m', 2)]) - self.assertEqual(parseDateTimePattern('HH:mm:ss'), - [('H', 2), ':', ('m', 2), ':', ('s', 2)]) - self.assertEqual(parseDateTimePattern('mm:ss'), - [('m', 2), ':', ('s', 2)]) - self.assertEqual(parseDateTimePattern('H:m:s'), - [('H', 1), ':', ('m', 1), ':', ('s', 1)]) - self.assertEqual(parseDateTimePattern('HHH:mmmm:sssss'), - [('H', 3), ':', ('m', 4), ':', ('s', 5)]) + self.assertEqual(parseDateTimePattern('HH'), [('H', 2)]) + self.assertEqual( + parseDateTimePattern('HH:mm'), [('H', 2), ':', ('m', 2)] + ) + self.assertEqual( + parseDateTimePattern('HH:mm:ss'), + [('H', 2), ':', ('m', 2), ':', ('s', 2)], + ) + self.assertEqual( + parseDateTimePattern('mm:ss'), [('m', 2), ':', ('s', 2)] + ) + self.assertEqual( + parseDateTimePattern('H:m:s'), + [('H', 1), ':', ('m', 1), ':', ('s', 1)], + ) + self.assertEqual( + parseDateTimePattern('HHH:mmmm:sssss'), + [('H', 3), ':', ('m', 4), ':', ('s', 5)], + ) def testParseGermanTimePattern(self): # German full - self.assertEqual(parseDateTimePattern("H:mm' Uhr 'z"), - [('H', 1), ':', ('m', 2), ' Uhr ', ('z', 1)]) + self.assertEqual( + parseDateTimePattern("H:mm' Uhr 'z"), + [('H', 1), ':', ('m', 2), ' Uhr ', ('z', 1)], + ) # German long - self.assertEqual(parseDateTimePattern("HH:mm:ss z"), - [('H', 2), ':', ('m', 2), ':', ('s', 2), ' ', - ('z', 1)]) + self.assertEqual( + parseDateTimePattern("HH:mm:ss z"), + [('H', 2), ':', ('m', 2), ':', ('s', 2), ' ', ('z', 1)], + ) # German medium - self.assertEqual(parseDateTimePattern("HH:mm:ss"), - [('H', 2), ':', ('m', 2), ':', ('s', 2)]) + self.assertEqual( + parseDateTimePattern("HH:mm:ss"), + [('H', 2), ':', ('m', 2), ':', ('s', 2)], + ) # German short - self.assertEqual(parseDateTimePattern("HH:mm"), - [('H', 2), ':', ('m', 2)]) + self.assertEqual( + parseDateTimePattern("HH:mm"), [('H', 2), ':', ('m', 2)] + ) def testParseRealDate(self): # German full - self.assertEqual(parseDateTimePattern("EEEE, d. MMMM yyyy"), - [('E', 4), ', ', ('d', 1), '. ', ('M', 4), - ' ', ('y', 4)]) + self.assertEqual( + parseDateTimePattern("EEEE, d. MMMM yyyy"), + [('E', 4), ', ', ('d', 1), '. ', ('M', 4), ' ', ('y', 4)], + ) # German long - self.assertEqual(parseDateTimePattern("d. MMMM yyyy"), - [('d', 1), '. ', ('M', 4), ' ', ('y', 4)]) + self.assertEqual( + parseDateTimePattern("d. MMMM yyyy"), + [('d', 1), '. ', ('M', 4), ' ', ('y', 4)], + ) # German medium - self.assertEqual(parseDateTimePattern("dd.MM.yyyy"), - [('d', 2), '.', ('M', 2), '.', ('y', 4)]) + self.assertEqual( + parseDateTimePattern("dd.MM.yyyy"), + [('d', 2), '.', ('M', 2), '.', ('y', 4)], + ) # German short - self.assertEqual(parseDateTimePattern("dd.MM.yy"), - [('d', 2), '.', ('M', 2), '.', ('y', 2)]) + self.assertEqual( + parseDateTimePattern("dd.MM.yy"), + [('d', 2), '.', ('M', 2), '.', ('y', 2)], + ) def testParseRealDateTime(self): # German full self.assertEqual( parseDateTimePattern("EEEE, d. MMMM yyyy H:mm' Uhr 'z"), - [('E', 4), ', ', ('d', 1), '. ', ('M', 4), ' ', ('y', 4), - ' ', ('H', 1), ':', ('m', 2), ' Uhr ', ('z', 1)]) + [ + ('E', 4), + ', ', + ('d', 1), + '. ', + ('M', 4), + ' ', + ('y', 4), + ' ', + ('H', 1), + ':', + ('m', 2), + ' Uhr ', + ('z', 1), + ], + ) # German long self.assertEqual( parseDateTimePattern("d. MMMM yyyy HH:mm:ss z"), - [('d', 1), '. ', ('M', 4), ' ', ('y', 4), - ' ', ('H', 2), ':', ('m', 2), ':', ('s', 2), ' ', ('z', 1)]) + [ + ('d', 1), + '. ', + ('M', 4), + ' ', + ('y', 4), + ' ', + ('H', 2), + ':', + ('m', 2), + ':', + ('s', 2), + ' ', + ('z', 1), + ], + ) # German medium self.assertEqual( parseDateTimePattern("dd.MM.yyyy HH:mm:ss"), - [('d', 2), '.', ('M', 2), '.', ('y', 4), - ' ', ('H', 2), ':', ('m', 2), ':', ('s', 2)]) + [ + ('d', 2), + '.', + ('M', 2), + '.', + ('y', 4), + ' ', + ('H', 2), + ':', + ('m', 2), + ':', + ('s', 2), + ], + ) # German short self.assertEqual( parseDateTimePattern("dd.MM.yy HH:mm"), - [('d', 2), '.', ('M', 2), '.', ('y', 2), - ' ', ('H', 2), ':', ('m', 2)]) + [ + ('d', 2), + '.', + ('M', 2), + '.', + ('y', 2), + ' ', + ('H', 2), + ':', + ('m', 2), + ], + ) def testParseQuotesInPattern(self): - self.assertEqual(parseDateTimePattern("HH''mm"), - [('H', 2), "'", ('m', 2)]) - self.assertEqual(parseDateTimePattern("HH'HHmm'mm"), - [('H', 2), 'HHmm', ('m', 2)]) - self.assertEqual(parseDateTimePattern("HH':'''':'mm"), - [('H', 2), ":':", ('m', 2)]) - self.assertEqual(parseDateTimePattern("HH':' ':'mm"), - [('H', 2), ": :", ('m', 2)]) + self.assertEqual( + parseDateTimePattern("HH''mm"), [('H', 2), "'", ('m', 2)] + ) + self.assertEqual( + parseDateTimePattern("HH'HHmm'mm"), [('H', 2), 'HHmm', ('m', 2)] + ) + self.assertEqual( + parseDateTimePattern("HH':'''':'mm"), [('H', 2), ":':", ('m', 2)] + ) + self.assertEqual( + parseDateTimePattern("HH':' ':'mm"), [('H', 2), ": :", ('m', 2)] + ) def testParseDateTimePatternError(self): # Quote not closed with self.assertRaisesRegex( - DateTimePatternParseError, - 'The quote starting at character 2 is not closed.'): + DateTimePatternParseError, + 'The quote starting at character 2 is not closed.', + ): parseDateTimePattern("HH' Uhr") # Test correct length of characters in datetime fields @@ -198,10 +279,7 @@ class TestDateTimePatternParser(_TestCase): def testParseDateTimePatternRepeatDateTimeChars(self): result = parseDateTimePattern('aG') - self.assertEqual( - result, - [('a', 1), ('G', 1)] - ) + self.assertEqual(result, [('a', 1), ('G', 1)]) class TestBuildDateTimeParseInfo(_TestCase): @@ -216,8 +294,10 @@ class TestBuildDateTimeParseInfo(_TestCase): def testGenericNumbers(self): for char in 'dDFkKhHmsSwW': for length in range(1, 6): - self.assertEqual(self.info((char, length)), - '([0-9]{%i,1000})' %length) + self.assertEqual( + self.info((char, length)), '([0-9]{%i,1000})' % length + ) + def testYear(self): self.assertEqual(self.info(('y', 2)), '([0-9]{2})') self.assertEqual(self.info(('y', 4)), '([0-9]{4})') @@ -228,7 +308,9 @@ class TestBuildDateTimeParseInfo(_TestCase): def testAMPMMarker(self): names = ['vorm.', 'nachm.'] for length in range(1, 6): - self.assertEqual(self.info(('a', length)), '('+'|'.join(names)+')') + self.assertEqual( + self.info(('a', length)), '(' + '|'.join(names) + ')' + ) def testEra(self): self.assertEqual(self.info(('G', 1)), '(v. Chr.|n. Chr.)') @@ -245,30 +327,60 @@ class TestBuildDateTimeParseInfo(_TestCase): self.assertEqual(self.info(('M', 2)), '([0-9]{2})') def testMonthNames(self): - names = [u"Januar", u"Februar", u"Maerz", u"April", - u"Mai", u"Juni", u"Juli", u"August", u"September", u"Oktober", - u"November", u"Dezember"] - self.assertEqual(self.info(('M', 4)), '('+'|'.join(names)+')') + names = [ + u"Januar", + u"Februar", + u"Maerz", + u"April", + u"Mai", + u"Juni", + u"Juli", + u"August", + u"September", + u"Oktober", + u"November", + u"Dezember", + ] + self.assertEqual(self.info(('M', 4)), '(' + '|'.join(names) + ')') def testMonthAbbr(self): - names = ['Jan', 'Feb', 'Mrz', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', - 'Sep', 'Okt', 'Nov', 'Dez'] - self.assertEqual(self.info(('M', 3)), '('+'|'.join(names)+')') + names = [ + 'Jan', + 'Feb', + 'Mrz', + 'Apr', + 'Mai', + 'Jun', + 'Jul', + 'Aug', + 'Sep', + 'Okt', + 'Nov', + 'Dez', + ] + self.assertEqual(self.info(('M', 3)), '(' + '|'.join(names) + ')') def testWeekdayNumber(self): self.assertEqual(self.info(('E', 1)), '([0-9])') self.assertEqual(self.info(('E', 2)), '([0-9]{2})') def testWeekdayNames(self): - names = ['Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', - 'Freitag', 'Samstag', 'Sonntag'] - self.assertEqual(self.info(('E', 4)), '('+'|'.join(names)+')') - self.assertEqual(self.info(('E', 5)), '('+'|'.join(names)+')') - self.assertEqual(self.info(('E', 10)), '('+'|'.join(names)+')') + names = [ + 'Montag', + 'Dienstag', + 'Mittwoch', + 'Donnerstag', + 'Freitag', + 'Samstag', + 'Sonntag', + ] + self.assertEqual(self.info(('E', 4)), '(' + '|'.join(names) + ')') + self.assertEqual(self.info(('E', 5)), '(' + '|'.join(names) + ')') + self.assertEqual(self.info(('E', 10)), '(' + '|'.join(names) + ')') def testWeekdayAbbr(self): names = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So'] - self.assertEqual(self.info(('E', 3)), '('+'|'.join(names)+')') + self.assertEqual(self.info(('E', 3)), '(' + '|'.join(names) + ')') class TestDateTimeFormat(_TestCase): @@ -284,36 +396,44 @@ class TestDateTimeFormat(_TestCase): # German short self.assertEqual( self.format.parse('02.01.03 21:48', 'dd.MM.yy HH:mm'), - datetime.datetime(2003, 1, 2, 21, 48)) + datetime.datetime(2003, 1, 2, 21, 48), + ) def testParseRealDateTime(self): # German medium self.assertEqual( self.format.parse('02.01.2003 21:48:01', 'dd.MM.yyyy HH:mm:ss'), - datetime.datetime(2003, 1, 2, 21, 48, 1)) + datetime.datetime(2003, 1, 2, 21, 48, 1), + ) # German long # TODO: The parser does not support timezones yet. self.assertEqual( self.format.parse( - '2. Januar 2003 21:48:01 +100', - 'd. MMMM yyyy HH:mm:ss z'), + '2. Januar 2003 21:48:01 +100', 'd. MMMM yyyy HH:mm:ss z' + ), pytz.timezone('Europe/Berlin').localize( - datetime.datetime(2003, 1, 2, 21, 48, 1))) + datetime.datetime(2003, 1, 2, 21, 48, 1) + ), + ) # German full # TODO: The parser does not support timezones yet. self.assertEqual( self.format.parse( 'Donnerstag, 2. Januar 2003 21:48 Uhr +100', - "EEEE, d. MMMM yyyy H:mm' Uhr 'z"), + "EEEE, d. MMMM yyyy H:mm' Uhr 'z", + ), pytz.timezone('Europe/Berlin').localize( - datetime.datetime(2003, 1, 2, 21, 48))) + datetime.datetime(2003, 1, 2, 21, 48) + ), + ) def testParseAMPMDateTime(self): self.assertEqual( self.format.parse('02.01.03 09:48 nachm.', 'dd.MM.yy hh:mm a'), - datetime.datetime(2003, 1, 2, 21, 48)) + datetime.datetime(2003, 1, 2, 21, 48), + ) def testParseTimeZone(self): dt = self.format.parse('09:48 -600', 'HH:mm z') @@ -338,15 +458,17 @@ class TestDateTimeFormat(_TestCase): self.assertEqual(dt.tzinfo.zone, 'EST') self.assertEqual(dt.tzinfo.tzname(dt), 'EST') - dt = self.format.parse('01.01.2003 09:48 US/Eastern', - 'dd.MM.yyyy HH:mm zzzz') + dt = self.format.parse( + '01.01.2003 09:48 US/Eastern', 'dd.MM.yyyy HH:mm zzzz' + ) self.assertEqual(pickle.loads(pickle.dumps(dt)), dt) self.assertEqual(dt.tzinfo.utcoffset(dt), datetime.timedelta(hours=-5)) self.assertEqual(dt.tzinfo.zone, 'US/Eastern') self.assertEqual(dt.tzinfo.tzname(dt), 'EST') - dt = self.format.parse('01.01.2003 09:48 Canada/Eastern', - 'dd.MM.yyyy HH:mm zzzz') + dt = self.format.parse( + '01.01.2003 09:48 Canada/Eastern', 'dd.MM.yyyy HH:mm zzzz' + ) self.assertEqual(dt.tzinfo.utcoffset(dt), datetime.timedelta(hours=-5)) self.assertEqual(dt.tzinfo.zone, 'Canada/Eastern') self.assertEqual(dt.tzinfo.tzname(dt), 'EST') @@ -354,13 +476,15 @@ class TestDateTimeFormat(_TestCase): # Note that historical and future (as far as known) # timezones are handled happily using the pytz timezone database # US DST transition points are changing in 2007 - dt = self.format.parse('01.04.2006 09:48 US/Eastern', - 'dd.MM.yyyy HH:mm zzzz') + dt = self.format.parse( + '01.04.2006 09:48 US/Eastern', 'dd.MM.yyyy HH:mm zzzz' + ) self.assertEqual(dt.tzinfo.zone, 'US/Eastern') self.assertEqual(dt.tzinfo.tzname(dt), 'EST') self.assertEqual(dt.tzinfo.utcoffset(dt), datetime.timedelta(hours=-5)) - dt = self.format.parse('01.04.2007 09:48 US/Eastern', - 'dd.MM.yyyy HH:mm zzzz') + dt = self.format.parse( + '01.04.2007 09:48 US/Eastern', 'dd.MM.yyyy HH:mm zzzz' + ) self.assertEqual(dt.tzinfo.zone, 'US/Eastern') self.assertEqual(dt.tzinfo.tzname(dt), 'EDT') self.assertEqual(dt.tzinfo.utcoffset(dt), datetime.timedelta(hours=-4)) @@ -376,65 +500,75 @@ class TestDateTimeFormat(_TestCase): def testParse12PM(self): self.assertEqual( self.format.parse('01.01.03 12:00 nachm.', 'dd.MM.yy hh:mm a'), - datetime.datetime(2003, 1, 1, 12, 00, 00, 00)) + datetime.datetime(2003, 1, 1, 12, 00, 00, 00), + ) def testParseUnusualFormats(self): self.assertEqual( - self.format.parse('001. Januar 03 0012:00', - 'ddd. MMMMM yy HHHH:mm'), - datetime.datetime(2003, 1, 1, 12, 00, 00, 00)) + self.format.parse( + '001. Januar 03 0012:00', 'ddd. MMMMM yy HHHH:mm' + ), + datetime.datetime(2003, 1, 1, 12, 00, 00, 00), + ) self.assertEqual( - self.format.parse('0001. Jan 2003 0012:00 vorm.', - 'dddd. MMM yyyy hhhh:mm a'), - datetime.datetime(2003, 1, 1, 00, 00, 00, 00)) + self.format.parse( + '0001. Jan 2003 0012:00 vorm.', 'dddd. MMM yyyy hhhh:mm a' + ), + datetime.datetime(2003, 1, 1, 00, 00, 00, 00), + ) def testParseNotObject(self): self.assertEqual( ('2017', '01', '01'), - self.format.parse('2017-01-01', 'yyyy-MM-dd', asObject=False)) + self.format.parse('2017-01-01', 'yyyy-MM-dd', asObject=False), + ) def testParseTwoDigitYearIs20thCentury(self): self.assertEqual( datetime.date(1952, 1, 1), - self.format.parse('52-01-01', 'yy-MM-dd')) + self.format.parse('52-01-01', 'yy-MM-dd'), + ) # 30 is the cut off self.assertEqual( datetime.date(1931, 1, 1), - self.format.parse('31-01-01', 'yy-MM-dd')) + self.format.parse('31-01-01', 'yy-MM-dd'), + ) self.assertEqual( datetime.date(2030, 1, 1), - self.format.parse('30-01-01', 'yy-MM-dd')) + self.format.parse('30-01-01', 'yy-MM-dd'), + ) def testParseAMPMMissing(self): with self.assertRaisesRegex( - DateTimeParseError, - 'Cannot handle 12-hour format without am/pm marker.'): + DateTimeParseError, + 'Cannot handle 12-hour format without am/pm marker.', + ): self.format.parse('02.01.03 09:48', 'dd.MM.yy hh:mm') def testParseBadTimezone(self): # Produces an object without pytz info self.assertEqual( datetime.time(21, 48, 1), - self.format.parse( - '21:48:01 Bad/Timezone', - 'HH:mm:ss zzzz')) + self.format.parse('21:48:01 Bad/Timezone', 'HH:mm:ss zzzz'), + ) def testParsePyTzTimezone(self): tzinfo = pytz.timezone("US/Central") self.assertEqual( datetime.time(21, 48, 1, tzinfo=tzinfo), - self.format.parse( - '21:48:01 US/Central', - 'HH:mm:ss zzzz')) + self.format.parse('21:48:01 US/Central', 'HH:mm:ss zzzz'), + ) def testFormatSimpleDateTime(self): # German short self.assertEqual( - self.format.format(datetime.datetime(2003, 1, 2, 21, 48), - 'dd.MM.yy HH:mm'), - '02.01.03 21:48') + self.format.format( + datetime.datetime(2003, 1, 2, 21, 48), 'dd.MM.yy HH:mm' + ), + '02.01.03 21:48', + ) def testFormatRealDateTime(self): tz = pytz.timezone('Europe/Berlin') @@ -442,80 +576,89 @@ class TestDateTimeFormat(_TestCase): # German medium self.assertEqual( self.format.format(dt, 'dd.MM.yyyy HH:mm:ss'), - '02.01.2003 21:48:01') + '02.01.2003 21:48:01', + ) # German long self.assertEqual( self.format.format(dt, 'd. MMMM yyyy HH:mm:ss z'), - '2. Januar 2003 21:48:01 +100') + '2. Januar 2003 21:48:01 +100', + ) # German full self.assertEqual( - self.format.format( - dt, "EEEE, d. MMMM yyyy H:mm' Uhr 'z"), - 'Donnerstag, 2. Januar 2003 21:48 Uhr +100') + self.format.format(dt, "EEEE, d. MMMM yyyy H:mm' Uhr 'z"), + 'Donnerstag, 2. Januar 2003 21:48 Uhr +100', + ) def testFormatAMPMDateTime(self): self.assertEqual( self.format.format( - datetime.datetime(2003, 1, 2, 21, 48), - 'dd.MM.yy hh:mm a'), - '02.01.03 09:48 nachm.') + datetime.datetime(2003, 1, 2, 21, 48), 'dd.MM.yy hh:mm a' + ), + '02.01.03 09:48 nachm.', + ) def testFormatAllWeekdays(self): for day in range(1, 8): self.assertEqual( self.format.format( - datetime.datetime(2003, 1, day+5, 21, 48), - "EEEE, d. MMMM yyyy H:mm' Uhr 'z"), - '%s, %i. Januar 2003 21:48 Uhr +000' % ( - self.format.calendar.days[day][0], day+5)) + datetime.datetime(2003, 1, day + 5, 21, 48), + "EEEE, d. MMMM yyyy H:mm' Uhr 'z", + ), + '%s, %i. Januar 2003 21:48 Uhr +000' + % (self.format.calendar.days[day][0], day + 5), + ) def testFormatTimeZone(self): self.assertEqual( - self.format.format( - datetime.datetime(2003, 1, 2, 12, 00), 'z'), - '+000') + self.format.format(datetime.datetime(2003, 1, 2, 12, 00), 'z'), + '+000', + ) self.assertEqual( - self.format.format( - datetime.datetime(2003, 1, 2, 12, 00), 'zz'), - '+00:00') + self.format.format(datetime.datetime(2003, 1, 2, 12, 00), 'zz'), + '+00:00', + ) self.assertEqual( - self.format.format( - datetime.datetime(2003, 1, 2, 12, 00), 'zzz'), - 'UTC') + self.format.format(datetime.datetime(2003, 1, 2, 12, 00), 'zzz'), + 'UTC', + ) self.assertEqual( - self.format.format( - datetime.datetime(2003, 1, 2, 12, 00), 'zzzz'), - 'UTC') + self.format.format(datetime.datetime(2003, 1, 2, 12, 00), 'zzzz'), + 'UTC', + ) tz = pytz.timezone('US/Eastern') self.assertEqual( self.format.format( - tz.localize(datetime.datetime(2003, 1, 2, 12)), 'z'), - '-500') + tz.localize(datetime.datetime(2003, 1, 2, 12)), 'z' + ), + '-500', + ) self.assertEqual( self.format.format( - tz.localize(datetime.datetime(2003, 1, 2, 12)), 'zz'), - '-05:00') + tz.localize(datetime.datetime(2003, 1, 2, 12)), 'zz' + ), + '-05:00', + ) self.assertEqual( self.format.format( - tz.localize(datetime.datetime(2003, 1, 2, 12)), 'zzz'), - 'EST') + tz.localize(datetime.datetime(2003, 1, 2, 12)), 'zzz' + ), + 'EST', + ) self.assertEqual( self.format.format( - tz.localize(datetime.datetime(2003, 1, 2, 12)), 'zzzz'), - 'US/Eastern') + tz.localize(datetime.datetime(2003, 1, 2, 12)), 'zzzz' + ), + 'US/Eastern', + ) def testFormatWeekDay(self): date = datetime.date(2003, 1, 2) - self.assertEqual(self.format.format(date, "E"), - '4') - self.assertEqual(self.format.format(date, "EE"), - '04') - self.assertEqual(self.format.format(date, "EEE"), - 'Do') - self.assertEqual(self.format.format(date, "EEEE"), - 'Donnerstag') + self.assertEqual(self.format.format(date, "E"), '4') + self.assertEqual(self.format.format(date, "EE"), '04') + self.assertEqual(self.format.format(date, "EEE"), 'Do') + self.assertEqual(self.format.format(date, "EEEE"), 'Donnerstag') # Create custom calendar, which has Sunday as the first day of the # week. I am assigning a totally new dict here, since dicts are @@ -525,166 +668,146 @@ class TestDateTimeFormat(_TestCase): calendar.week = {'firstDay': 7, 'minDays': 1} format = DateTimeFormat(calendar=calendar) - self.assertEqual(format.format(date, "E"), - '5') - self.assertEqual(format.format(date, "EE"), - '05') + self.assertEqual(format.format(date, "E"), '5') + self.assertEqual(format.format(date, "EE"), '05') def testFormatDayOfWeekInMonth(self): date = datetime.date(2003, 1, 2) - self.assertEqual(self.format.format(date, "F"), - '1') - self.assertEqual(self.format.format(date, "FF"), - '01') + self.assertEqual(self.format.format(date, "F"), '1') + self.assertEqual(self.format.format(date, "FF"), '01') self.assertEqual( - self.format.format(datetime.date(2003, 1, 9), "F"), - '2') + self.format.format(datetime.date(2003, 1, 9), "F"), '2' + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 16), "F"), - '3') + self.format.format(datetime.date(2003, 1, 16), "F"), '3' + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 23), "F"), - '4') + self.format.format(datetime.date(2003, 1, 23), "F"), '4' + ) def testFormatWeekInMonth(self): self.assertEqual( - self.format.format(datetime.date(2003, 1, 3), "W"), - '1') + self.format.format(datetime.date(2003, 1, 3), "W"), '1' + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 3), "WW"), - '01') + self.format.format(datetime.date(2003, 1, 3), "WW"), '01' + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 8), "W"), - '2') + self.format.format(datetime.date(2003, 1, 8), "W"), '2' + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 19), "W"), - '3') + self.format.format(datetime.date(2003, 1, 19), "W"), '3' + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 20), "W"), - '4') + self.format.format(datetime.date(2003, 1, 20), "W"), '4' + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 31), "W"), - '5') + self.format.format(datetime.date(2003, 1, 31), "W"), '5' + ) def testFormatHourInDayOneTo24(self): - self.assertEqual( - self.format.format(datetime.time(5, 0), "k"), - '5') - self.assertEqual( - self.format.format(datetime.time(5, 0), "kk"), - '05') - self.assertEqual( - self.format.format(datetime.time(0, 0), "k"), - '24') - self.assertEqual( - self.format.format(datetime.time(1, 0), "k"), - '1') + self.assertEqual(self.format.format(datetime.time(5, 0), "k"), '5') + self.assertEqual(self.format.format(datetime.time(5, 0), "kk"), '05') + self.assertEqual(self.format.format(datetime.time(0, 0), "k"), '24') + self.assertEqual(self.format.format(datetime.time(1, 0), "k"), '1') def testFormatHourInDayZeroToEleven(self): - self.assertEqual( - self.format.format(datetime.time(5, 0), "K"), - '5') - self.assertEqual( - self.format.format(datetime.time(5, 0), "KK"), - '05') - self.assertEqual( - self.format.format(datetime.time(0, 0), "K"), - '0') - self.assertEqual( - self.format.format(datetime.time(12, 0), "K"), - '0') - self.assertEqual( - self.format.format(datetime.time(11, 0), "K"), - '11') - self.assertEqual( - self.format.format(datetime.time(23, 0), "K"), - '11') + self.assertEqual(self.format.format(datetime.time(5, 0), "K"), '5') + self.assertEqual(self.format.format(datetime.time(5, 0), "KK"), '05') + self.assertEqual(self.format.format(datetime.time(0, 0), "K"), '0') + self.assertEqual(self.format.format(datetime.time(12, 0), "K"), '0') + self.assertEqual(self.format.format(datetime.time(11, 0), "K"), '11') + self.assertEqual(self.format.format(datetime.time(23, 0), "K"), '11') def testFormatSimpleHourRepresentation(self): self.assertEqual( - self.format.format(datetime.datetime(2003, 1, 2, 23, 00), - 'dd.MM.yy h:mm:ss a'), - '02.01.03 11:00:00 nachm.') + self.format.format( + datetime.datetime(2003, 1, 2, 23, 00), 'dd.MM.yy h:mm:ss a' + ), + '02.01.03 11:00:00 nachm.', + ) self.assertEqual( - self.format.format(datetime.datetime(2003, 1, 2, 2, 00), - 'dd.MM.yy h:mm:ss a'), - '02.01.03 2:00:00 vorm.') + self.format.format( + datetime.datetime(2003, 1, 2, 2, 00), 'dd.MM.yy h:mm:ss a' + ), + '02.01.03 2:00:00 vorm.', + ) self.assertEqual( - self.format.format(datetime.time(0, 15), 'h:mm a'), - '12:15 vorm.') + self.format.format(datetime.time(0, 15), 'h:mm a'), '12:15 vorm.' + ) self.assertEqual( - self.format.format(datetime.time(1, 15), 'h:mm a'), - '1:15 vorm.') + self.format.format(datetime.time(1, 15), 'h:mm a'), '1:15 vorm.' + ) self.assertEqual( - self.format.format(datetime.time(12, 15), 'h:mm a'), - '12:15 nachm.') + self.format.format(datetime.time(12, 15), 'h:mm a'), '12:15 nachm.' + ) self.assertEqual( - self.format.format(datetime.time(13, 15), 'h:mm a'), - '1:15 nachm.') + self.format.format(datetime.time(13, 15), 'h:mm a'), '1:15 nachm.' + ) def testFormatDayInYear(self): self.assertEqual( - self.format.format(datetime.date(2003, 1, 3), 'D'), - u"3") + self.format.format(datetime.date(2003, 1, 3), 'D'), u"3" + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 3), 'DD'), - u"03") + self.format.format(datetime.date(2003, 1, 3), 'DD'), u"03" + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 3), 'DDD'), - u"003") + self.format.format(datetime.date(2003, 1, 3), 'DDD'), u"003" + ) self.assertEqual( - self.format.format(datetime.date(2003, 12, 31), 'D'), - u"365") + self.format.format(datetime.date(2003, 12, 31), 'D'), u"365" + ) self.assertEqual( - self.format.format(datetime.date(2003, 12, 31), 'DD'), - u"365") + self.format.format(datetime.date(2003, 12, 31), 'DD'), u"365" + ) self.assertEqual( - self.format.format(datetime.date(2003, 12, 31), 'DDD'), - u"365") + self.format.format(datetime.date(2003, 12, 31), 'DDD'), u"365" + ) self.assertEqual( - self.format.format(datetime.date(2004, 12, 31), 'DDD'), - u"366") + self.format.format(datetime.date(2004, 12, 31), 'DDD'), u"366" + ) def testFormatDayOfWeekInMOnth(self): self.assertEqual( - self.format.format(datetime.date(2003, 1, 3), 'F'), - u"1") + self.format.format(datetime.date(2003, 1, 3), 'F'), u"1" + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 10), 'F'), - u"2") + self.format.format(datetime.date(2003, 1, 10), 'F'), u"2" + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 17), 'F'), - u"3") + self.format.format(datetime.date(2003, 1, 17), 'F'), u"3" + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 24), 'F'), - u"4") + self.format.format(datetime.date(2003, 1, 24), 'F'), u"4" + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 31), 'F'), - u"5") + self.format.format(datetime.date(2003, 1, 31), 'F'), u"5" + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 6), 'F'), - u"1") + self.format.format(datetime.date(2003, 1, 6), 'F'), u"1" + ) def testFormatUnusualFormats(self): self.assertEqual( self.format.format(datetime.date(2003, 1, 3), 'DDD-yyyy'), - u"003-2003") + u"003-2003", + ) self.assertEqual( - self.format.format(datetime.date(2003, 1, 10), - "F. EEEE 'im' MMMM, yyyy"), - u"2. Freitag im Januar, 2003") - + self.format.format( + datetime.date(2003, 1, 10), "F. EEEE 'im' MMMM, yyyy" + ), + u"2. Freitag im Januar, 2003", + ) def testFormatGregorianEra(self): self.assertEqual( - self.format.format(datetime.date(2017, 12, 17), 'G'), - u'n. Chr.' + self.format.format(datetime.date(2017, 12, 17), 'G'), u'n. Chr.' ) def testFormateMonthLengthOne(self): self.assertEqual( - self.format.format(datetime.date(2017, 12, 17), 'M'), - u'12' + self.format.format(datetime.date(2017, 12, 17), 'M'), u'12' ) @@ -694,515 +817,757 @@ class TestNumberPatternParser(_TestCase): def testParseSimpleIntegerPattern(self): self.assertEqual( parseNumberPattern('###0'), - ((None, '', None, '###0', '', '', None, '', None, ()), - (None, '', None, '###0', '', '', None, '', None, ()))) + ( + (None, '', None, '###0', '', '', None, '', None, ()), + (None, '', None, '###0', '', '', None, '', None, ()), + ), + ) def testParseScientificIntegerPattern(self): self.assertEqual( parseNumberPattern('###0E#0'), - ((None, '', None, '###0', '', '#0', None, '', None, ()), - (None, '', None, '###0', '', '#0', None, '', None, ()))) + ( + (None, '', None, '###0', '', '#0', None, '', None, ()), + (None, '', None, '###0', '', '#0', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('###0E+#0'), - ((None, '', None, '###0', '', '+#0', None, '', None, ()), - (None, '', None, '###0', '', '+#0', None, '', None, ()))) + ( + (None, '', None, '###0', '', '+#0', None, '', None, ()), + (None, '', None, '###0', '', '+#0', None, '', None, ()), + ), + ) def testParsePosNegAlternativeIntegerPattern(self): self.assertEqual( parseNumberPattern('###0;#0'), - ((None, '', None, '###0', '', '', None, '', None, ()), - (None, '', None, '#0', '', '', None, '', None, ()))) + ( + (None, '', None, '###0', '', '', None, '', None, ()), + (None, '', None, '#0', '', '', None, '', None, ()), + ), + ) def testParsePrefixedIntegerPattern(self): self.assertEqual( parseNumberPattern('+###0'), - ((None, '+', None, '###0', '', '', None, '', None, ()), - (None, '+', None, '###0', '', '', None, '', None, ()))) + ( + (None, '+', None, '###0', '', '', None, '', None, ()), + (None, '+', None, '###0', '', '', None, '', None, ()), + ), + ) def testParsePosNegIntegerPattern(self): self.assertEqual( parseNumberPattern('+###0;-###0'), - ((None, '+', None, '###0', '', '', None, '', None, ()), - (None, '-', None, '###0', '', '', None, '', None, ()))) + ( + (None, '+', None, '###0', '', '', None, '', None, ()), + (None, '-', None, '###0', '', '', None, '', None, ()), + ), + ) def testParseScientificPosNegIntegerPattern(self): self.assertEqual( parseNumberPattern('+###0E0;-###0E#0'), - ((None, '+', None, '###0', '', '0', None, '', None, ()), - (None, '-', None, '###0', '', '#0', None, '', None, ()))) + ( + (None, '+', None, '###0', '', '0', None, '', None, ()), + (None, '-', None, '###0', '', '#0', None, '', None, ()), + ), + ) def testParseThousandSeparatorIntegerPattern(self): self.assertEqual( parseNumberPattern('#,##0'), - ((None, '', None, '###0', '', '', None, '', None, (3, 0)), - (None, '', None, '###0', '', '', None, '', None, (3, 0)))) + ( + (None, '', None, '###0', '', '', None, '', None, (3, 0)), + (None, '', None, '###0', '', '', None, '', None, (3, 0)), + ), + ) def testParseSimpleDecimalPattern(self): self.assertEqual( parseNumberPattern('###0.00#'), - ((None, '', None, '###0', '00#', '', None, '', None, ()), - (None, '', None, '###0', '00#', '', None, '', None, ()))) + ( + (None, '', None, '###0', '00#', '', None, '', None, ()), + (None, '', None, '###0', '00#', '', None, '', None, ()), + ), + ) def testParseScientificDecimalPattern(self): self.assertEqual( parseNumberPattern('###0.00#E#0'), - ((None, '', None, '###0', '00#', '#0', None, '', None, ()), - (None, '', None, '###0', '00#', '#0', None, '', None, ()))) + ( + (None, '', None, '###0', '00#', '#0', None, '', None, ()), + (None, '', None, '###0', '00#', '#0', None, '', None, ()), + ), + ) def testParsePosNegAlternativeFractionPattern(self): self.assertEqual( parseNumberPattern('###0.00#;#0.0#'), - ((None, '', None, '###0', '00#', '', None, '', None, ()), - (None, '', None, '#0', '0#', '', None, '', None, ()))) + ( + (None, '', None, '###0', '00#', '', None, '', None, ()), + (None, '', None, '#0', '0#', '', None, '', None, ()), + ), + ) def testParsePosNegFractionPattern(self): self.assertEqual( parseNumberPattern('+###0.0##;-###0.0##'), - ((None, '+', None, '###0', '0##', '', None, '', None, ()), - (None, '-', None, '###0', '0##', '', None, '', None, ()))) + ( + (None, '+', None, '###0', '0##', '', None, '', None, ()), + (None, '-', None, '###0', '0##', '', None, '', None, ()), + ), + ) def testParseScientificPosNegFractionPattern(self): self.assertEqual( parseNumberPattern('+###0.0##E#0;-###0.0##E0'), - ((None, '+', None, '###0', '0##', '#0', None, '', None, ()), - (None, '-', None, '###0', '0##', '0', None, '', None, ()))) + ( + (None, '+', None, '###0', '0##', '#0', None, '', None, ()), + (None, '-', None, '###0', '0##', '0', None, '', None, ()), + ), + ) def testParseThousandSeparatorFractionPattern(self): self.assertEqual( parseNumberPattern('#,##0.0#'), - ((None, '', None, '###0', '0#', '', None, '', None, (3, 0)), - (None, '', None, '###0', '0#', '', None, '', None, (3, 0)))) + ( + (None, '', None, '###0', '0#', '', None, '', None, (3, 0)), + (None, '', None, '###0', '0#', '', None, '', None, (3, 0)), + ), + ) def testParseThousandSeparatorPatterns(self): # the following patterns are present in the ICU XMLs: self.assertEqual( parseNumberPattern('#,##0.00;-#,##0.00'), - ((None, '', None, '###0', '00', '', None, '', None, (3, 0)), - (None, '-', None, '###0', '00', '', None, '', None, (3, 0)))) + ( + (None, '', None, '###0', '00', '', None, '', None, (3, 0)), + (None, '-', None, '###0', '00', '', None, '', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('#,##,##0.###;-#,##,##0.###'), - ((None, '', None, '#####0', '###', '', None, '', None, (3, 2, 0)), - (None, '-', None, '#####0', '###', '', None, '', None, (3, 2, 0)))) + ( + ( + None, + '', + None, + '#####0', + '###', + '', + None, + '', + None, + (3, 2, 0), + ), + ( + None, + '-', + None, + '#####0', + '###', + '', + None, + '', + None, + (3, 2, 0), + ), + ), + ) self.assertEqual( parseNumberPattern('#,##0.##;-#,##0.##'), - ((None, '', None, '###0', '##', '', None, '', None, (3, 0)), - (None, '-', None, '###0', '##', '', None, '', None, (3, 0)))) + ( + (None, '', None, '###0', '##', '', None, '', None, (3, 0)), + (None, '-', None, '###0', '##', '', None, '', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('#,##0.###;-#,##0.###'), - ((None, '', None, '###0', '###', '', None, '', None, (3, 0)), - (None, '-', None, '###0', '###', '', None, '', None, (3, 0)))) + ( + (None, '', None, '###0', '###', '', None, '', None, (3, 0)), + (None, '-', None, '###0', '###', '', None, '', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('#,##0.###;(#,##0.###)'), - ((None, '', None, '###0', '###', '', None, '', None, (3, 0)), - (None, '(', None, '###0', '###', '', None, ')', None, (3, 0)))) + ( + (None, '', None, '###0', '###', '', None, '', None, (3, 0)), + (None, '(', None, '###0', '###', '', None, ')', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('#,##0.###;#,##0.###-'), - ((None, '', None, '###0', '###', '', None, '', None, (3, 0)), - (None, '', None, '###0', '###', '', None, '-', None, (3, 0)))) + ( + (None, '', None, '###0', '###', '', None, '', None, (3, 0)), + (None, '', None, '###0', '###', '', None, '-', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('##,##,##0.###;-##,##,##0.###'), - ((None, '', None, '######0', '###', '', None, '', None, (3, 2, 0)), - (None, '-', None, '######0', '###', '', None, '', None, (3, 2, 0)))) + ( + ( + None, + '', + None, + '######0', + '###', + '', + None, + '', + None, + (3, 2, 0), + ), + ( + None, + '-', + None, + '######0', + '###', + '', + None, + '', + None, + (3, 2, 0), + ), + ), + ) self.assertEqual( parseNumberPattern('##,##0.##;-##,##0.##'), - ((None, '', None, '####0', '##', '', None, '', None, (3, 0)), - (None, '-', None, '####0', '##', '', None, '', None, (3, 0)))) + ( + (None, '', None, '####0', '##', '', None, '', None, (3, 0)), + (None, '-', None, '####0', '##', '', None, '', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('###0.###;-###0.###'), - ((None, '', None, '###0', '###', '', None, '', None, ()), - (None, '-', None, '###0', '###', '', None, '', None, ()))) + ( + (None, '', None, '###0', '###', '', None, '', None, ()), + (None, '-', None, '###0', '###', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('###0.###;###0.###-'), - ((None, '', None, '###0', '###', '', None, '', None, ()), - (None, '', None, '###0', '###', '', None, '-', None, ()))) + ( + (None, '', None, '###0', '###', '', None, '', None, ()), + (None, '', None, '###0', '###', '', None, '-', None, ()), + ), + ) self.assertEqual( parseNumberPattern('#0.###;-#0.###'), - ((None, '', None, '#0', '###', '', None, '', None, ()), - (None, '-', None, '#0', '###', '', None, '', None, ()))) + ( + (None, '', None, '#0', '###', '', None, '', None, ()), + (None, '-', None, '#0', '###', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('#,##0.###;#,##0.###'), - ((None, '', None, '###0', '###', '', None, '', None, (3, 0)), - (None, '', None, '###0', '###', '', None, '', None, (3, 0)))) + ( + (None, '', None, '###0', '###', '', None, '', None, (3, 0)), + (None, '', None, '###0', '###', '', None, '', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('###0.###;-###0.###'), - ((None, '', None, '###0', '###', '', None, '', None, ()), - (None, '-', None, '###0', '###', '', None, '', None, ()))) + ( + (None, '', None, '###0', '###', '', None, '', None, ()), + (None, '-', None, '###0', '###', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('#,##0.00;-#,##0.00'), - ((None, '', None, '###0', '00', '', None, '', None, (3, 0)), - (None, '-', None, '###0', '00', '', None, '', None, (3, 0)))) + ( + (None, '', None, '###0', '00', '', None, '', None, (3, 0)), + (None, '-', None, '###0', '00', '', None, '', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('#,##0.00;(#,##0.00)'), - ((None, '', None, '###0', '00', '', None, '', None, (3, 0)), - (None, '(', None, '###0', '00', '', None, ')', None, (3, 0)))) + ( + (None, '', None, '###0', '00', '', None, '', None, (3, 0)), + (None, '(', None, '###0', '00', '', None, ')', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('#,##0.00;-#,##0.00'), - ((None, '', None, '###0', '00', '', None, '', None, (3, 0)), - (None, '-', None, '###0', '00', '', None, '', None, (3, 0)))) + ( + (None, '', None, '###0', '00', '', None, '', None, (3, 0)), + (None, '-', None, '###0', '00', '', None, '', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('##,##,##0.00;-##,##,##0.00'), - ((None, '', None, '######0', '00', '', None, '', None, (3, 2, 0)), - (None, '-', None, '######0', '00', '', None, '', None, (3, 2, 0)))) + ( + ( + None, + '', + None, + '######0', + '00', + '', + None, + '', + None, + (3, 2, 0), + ), + ( + None, + '-', + None, + '######0', + '00', + '', + None, + '', + None, + (3, 2, 0), + ), + ), + ) self.assertEqual( parseNumberPattern('###0.00;-###0.00'), - ((None, '', None, '###0', '00', '', None, '', None, ()), - (None, '-', None, '###0', '00', '', None, '', None, ()))) + ( + (None, '', None, '###0', '00', '', None, '', None, ()), + (None, '-', None, '###0', '00', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('#,##0;-#,##0'), - ((None, '', None, '###0', '', '', None, '', None, (3, 0)), - (None, '-', None, '###0', '', '', None, '', None, (3, 0)))) + ( + (None, '', None, '###0', '', '', None, '', None, (3, 0)), + (None, '-', None, '###0', '', '', None, '', None, (3, 0)), + ), + ) self.assertEqual( parseNumberPattern('###0.00;-###0.00'), - ((None, '', None, '###0', '00', '', None, '', None, ()), - (None, '-', None, '###0', '00', '', None, '', None, ()))) + ( + (None, '', None, '###0', '00', '', None, '', None, ()), + (None, '-', None, '###0', '00', '', None, '', None, ()), + ), + ) def testParsePadding1WithoutPrefixPattern(self): self.assertEqual( parseNumberPattern('* ###0'), - ((' ', '', None, '###0', '', '', None, '', None, ()), - (' ', '', None, '###0', '', '', None, '', None, ()))) + ( + (' ', '', None, '###0', '', '', None, '', None, ()), + (' ', '', None, '###0', '', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('* ###0.0##'), - ((' ', '', None, '###0', '0##', '', None, '', None, ()), - (' ', '', None, '###0', '0##', '', None, '', None, ()))) + ( + (' ', '', None, '###0', '0##', '', None, '', None, ()), + (' ', '', None, '###0', '0##', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('* ###0.0##;*_###0.0##'), - ((' ', '', None, '###0', '0##', '', None, '', None, ()), - ('_', '', None, '###0', '0##', '', None, '', None, ()))) + ( + (' ', '', None, '###0', '0##', '', None, '', None, ()), + ('_', '', None, '###0', '0##', '', None, '', None, ()), + ), + ) def testParsePadding1WithPrefixPattern(self): self.assertEqual( parseNumberPattern('* +###0'), - ((' ', '+', None, '###0', '', '', None, '', None, ()), - (' ', '+', None, '###0', '', '', None, '', None, ()))) + ( + (' ', '+', None, '###0', '', '', None, '', None, ()), + (' ', '+', None, '###0', '', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('* +###0.0##'), - ((' ', '+', None, '###0', '0##', '', None, '', None, ()), - (' ', '+', None, '###0', '0##', '', None, '', None, ()))) + ( + (' ', '+', None, '###0', '0##', '', None, '', None, ()), + (' ', '+', None, '###0', '0##', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('* +###0.0##;*_-###0.0##'), - ((' ', '+', None, '###0', '0##', '', None, '', None, ()), - ('_', '-', None, '###0', '0##', '', None, '', None, ()))) + ( + (' ', '+', None, '###0', '0##', '', None, '', None, ()), + ('_', '-', None, '###0', '0##', '', None, '', None, ()), + ), + ) def testParsePadding1Padding2WithPrefixPattern(self): self.assertEqual( parseNumberPattern('* +* ###0'), - ((' ', '+', ' ', '###0', '', '', None, '', None, ()), - (' ', '+', ' ', '###0', '', '', None, '', None, ()))) + ( + (' ', '+', ' ', '###0', '', '', None, '', None, ()), + (' ', '+', ' ', '###0', '', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('* +* ###0.0##'), - ((' ', '+', ' ', '###0', '0##', '', None, '', None, ()), - (' ', '+', ' ', '###0', '0##', '', None, '', None, ()))) + ( + (' ', '+', ' ', '###0', '0##', '', None, '', None, ()), + (' ', '+', ' ', '###0', '0##', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('* +* ###0.0##;*_-*_###0.0##'), - ((' ', '+', ' ', '###0', '0##', '', None, '', None, ()), - ('_', '-', '_', '###0', '0##', '', None, '', None, ()))) + ( + (' ', '+', ' ', '###0', '0##', '', None, '', None, ()), + ('_', '-', '_', '###0', '0##', '', None, '', None, ()), + ), + ) def testParsePadding3WithoutSuffixPattern(self): self.assertEqual( parseNumberPattern('###0* '), - ((None, '', None, '###0', '', '', ' ', '', None, ()), - (None, '', None, '###0', '', '', ' ', '', None, ()))) + ( + (None, '', None, '###0', '', '', ' ', '', None, ()), + (None, '', None, '###0', '', '', ' ', '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('###0.0##* '), - ((None, '', None, '###0', '0##', '', ' ', '', None, ()), - (None, '', None, '###0', '0##', '', ' ', '', None, ()))) + ( + (None, '', None, '###0', '0##', '', ' ', '', None, ()), + (None, '', None, '###0', '0##', '', ' ', '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('###0.0##* ;###0.0##*_'), - ((None, '', None, '###0', '0##', '', ' ', '', None, ()), - (None, '', None, '###0', '0##', '', '_', '', None, ()))) + ( + (None, '', None, '###0', '0##', '', ' ', '', None, ()), + (None, '', None, '###0', '0##', '', '_', '', None, ()), + ), + ) def testParsePadding3InScientificPattern(self): self.assertEqual( parseNumberPattern('###0E#0* '), - ((None, '', None, '###0', '', '#0', ' ', '', None, ()), - (None, '', None, '###0', '', '#0', ' ', '', None, ()))) + ( + (None, '', None, '###0', '', '#0', ' ', '', None, ()), + (None, '', None, '###0', '', '#0', ' ', '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('###0.0##E0* '), - ((None, '', None, '###0', '0##', '0', ' ', '', None, ()), - (None, '', None, '###0', '0##', '0', ' ', '', None, ()))) + ( + (None, '', None, '###0', '0##', '0', ' ', '', None, ()), + (None, '', None, '###0', '0##', '0', ' ', '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('###0.0##E#0* ;###0.0##E0*_'), - ((None, '', None, '###0', '0##', '#0', ' ', '', None, ()), - (None, '', None, '###0', '0##', '0', '_', '', None, ()))) + ( + (None, '', None, '###0', '0##', '#0', ' ', '', None, ()), + (None, '', None, '###0', '0##', '0', '_', '', None, ()), + ), + ) def testParsePadding3WithSufffixPattern(self): self.assertEqual( parseNumberPattern('###0* /'), - ((None, '', None, '###0', '', '', ' ', '/', None, ()), - (None, '', None, '###0', '', '', ' ', '/', None, ()))) + ( + (None, '', None, '###0', '', '', ' ', '/', None, ()), + (None, '', None, '###0', '', '', ' ', '/', None, ()), + ), + ) self.assertEqual( parseNumberPattern('###0.0#* /'), - ((None, '', None, '###0', '0#', '', ' ', '/', None, ()), - (None, '', None, '###0', '0#', '', ' ', '/', None, ()))) + ( + (None, '', None, '###0', '0#', '', ' ', '/', None, ()), + (None, '', None, '###0', '0#', '', ' ', '/', None, ()), + ), + ) self.assertEqual( parseNumberPattern('###0.0#* /;###0.0#*_/'), - ((None, '', None, '###0', '0#', '', ' ', '/', None, ()), - (None, '', None, '###0', '0#', '', '_', '/', None, ()))) + ( + (None, '', None, '###0', '0#', '', ' ', '/', None, ()), + (None, '', None, '###0', '0#', '', '_', '/', None, ()), + ), + ) def testParsePadding3And4WithSuffixPattern(self): self.assertEqual( parseNumberPattern('###0* /* '), - ((None, '', None, '###0', '', '', ' ', '/', ' ', ()), - (None, '', None, '###0', '', '', ' ', '/', ' ', ()))) + ( + (None, '', None, '###0', '', '', ' ', '/', ' ', ()), + (None, '', None, '###0', '', '', ' ', '/', ' ', ()), + ), + ) self.assertEqual( parseNumberPattern('###0* /* ;###0*_/*_'), - ((None, '', None, '###0', '', '', ' ', '/', ' ', ()), - (None, '', None, '###0', '', '', '_', '/', '_', ()))) + ( + (None, '', None, '###0', '', '', ' ', '/', ' ', ()), + (None, '', None, '###0', '', '', '_', '/', '_', ()), + ), + ) def testParseMultipleCharacterPrefix(self): self.assertEqual( parseNumberPattern('DM###0'), - ((None, 'DM', None, '###0', '', '', None, '', None, ()), - (None, 'DM', None, '###0', '', '', None, '', None, ()))) + ( + (None, 'DM', None, '###0', '', '', None, '', None, ()), + (None, 'DM', None, '###0', '', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern('DM* ###0'), - ((None, 'DM', ' ', '###0', '', '', None, '', None, ()), - (None, 'DM', ' ', '###0', '', '', None, '', None, ()))) + ( + (None, 'DM', ' ', '###0', '', '', None, '', None, ()), + (None, 'DM', ' ', '###0', '', '', None, '', None, ()), + ), + ) def testParseStringEscapedPrefix(self): self.assertEqual( parseNumberPattern("'DEM'###0"), - ((None, 'DEM', None, '###0', '', '', None, '', None, ()), - (None, 'DEM', None, '###0', '', '', None, '', None, ()))) + ( + (None, 'DEM', None, '###0', '', '', None, '', None, ()), + (None, 'DEM', None, '###0', '', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern("D'EM'###0"), - ((None, 'DEM', None, '###0', '', '', None, '', None, ()), - (None, 'DEM', None, '###0', '', '', None, '', None, ()))) + ( + (None, 'DEM', None, '###0', '', '', None, '', None, ()), + (None, 'DEM', None, '###0', '', '', None, '', None, ()), + ), + ) self.assertEqual( parseNumberPattern("D'E'M###0"), - ((None, 'DEM', None, '###0', '', '', None, '', None, ()), - (None, 'DEM', None, '###0', '', '', None, '', None, ()))) + ( + (None, 'DEM', None, '###0', '', '', None, '', None, ()), + (None, 'DEM', None, '###0', '', '', None, '', None, ()), + ), + ) def testParseStringEscapedSuffix(self): self.assertEqual( parseNumberPattern("###0'DEM'"), - ((None, '', None, '###0', '', '', None, 'DEM', None, ()), - (None, '', None, '###0', '', '', None, 'DEM', None, ()))) + ( + (None, '', None, '###0', '', '', None, 'DEM', None, ()), + (None, '', None, '###0', '', '', None, 'DEM', None, ()), + ), + ) self.assertEqual( parseNumberPattern("###0D'EM'"), - ((None, '', None, '###0', '', '', None, 'DEM', None, ()), - (None, '', None, '###0', '', '', None, 'DEM', None, ()))) + ( + (None, '', None, '###0', '', '', None, 'DEM', None, ()), + (None, '', None, '###0', '', '', None, 'DEM', None, ()), + ), + ) self.assertEqual( parseNumberPattern("###0D'E'M"), - ((None, '', None, '###0', '', '', None, 'DEM', None, ()), - (None, '', None, '###0', '', '', None, 'DEM', None, ()))) + ( + (None, '', None, '###0', '', '', None, 'DEM', None, ()), + (None, '', None, '###0', '', '', None, 'DEM', None, ()), + ), + ) def testParseInvalidBegin(self): - with self.assertRaisesRegex(NumberPatternParseError, - "Wrong syntax at beginning"): + with self.assertRaisesRegex( + NumberPatternParseError, "Wrong syntax at beginning" + ): parseNumberPattern(".") def testParseFractionQuote(self): pattern, neg_pattern = parseNumberPattern("0.'") self.assertEqual( - (None, '', None, '0', '', '', None, '', None, ()), - pattern) + (None, '', None, '0', '', '', None, '', None, ()), pattern + ) self.assertEqual( - (None, '', None, '0', '', '', None, '', None, ()), - neg_pattern) + (None, '', None, '0', '', '', None, '', None, ()), neg_pattern + ) def testParseExponentialQuote(self): pattern, neg_pattern = parseNumberPattern("0E'") self.assertEqual( - (None, '', None, '0', '', '', None, '', None, ()), - pattern) + (None, '', None, '0', '', '', None, '', None, ()), pattern + ) self.assertEqual( - (None, '', None, '0', '', '', None, '', None, ()), - neg_pattern) + (None, '', None, '0', '', '', None, '', None, ()), neg_pattern + ) def testParseExponentialNumber(self): pattern, neg_pattern = parseNumberPattern("0E1") self.assertEqual( - (None, '', None, '0', '', '', None, '1', None, ()), - pattern) + (None, '', None, '0', '', '', None, '1', None, ()), pattern + ) self.assertEqual( - (None, '', None, '0', '', '', None, '1', None, ()), - neg_pattern) + (None, '', None, '0', '', '', None, '1', None, ()), neg_pattern + ) class TestNumberFormat(_TestCase): """Test the functionality of an implmentation of the NumberFormat.""" - format = NumberFormat(symbols={ - 'decimal': '.', 'group': ',', 'list': ';', 'percentSign': '%', - 'nativeZeroDigit': '0', 'patternDigit': '#', 'plusSign': '+', - 'minusSign': '-', 'exponential': 'E', 'perMille': 'o/oo', - 'infinity': 'oo', 'nan': 'N/A'}) + format = NumberFormat( + symbols={ + 'decimal': '.', + 'group': ',', + 'list': ';', + 'percentSign': '%', + 'nativeZeroDigit': '0', + 'patternDigit': '#', + 'plusSign': '+', + 'minusSign': '-', + 'exponential': 'E', + 'perMille': 'o/oo', + 'infinity': 'oo', + 'nan': 'N/A', + } + ) def testInterfaceConformity(self): self.assertTrue(INumberFormat.providedBy(self.format)) def testParseSimpleInteger(self): - self.assertEqual(self.format.parse('23341', '###0'), - 23341) - self.assertEqual(self.format.parse('041', '#000'), - 41) + self.assertEqual(self.format.parse('23341', '###0'), 23341) + self.assertEqual(self.format.parse('041', '#000'), 41) def testParseScientificInteger(self): - self.assertEqual(self.format.parse('2.3341E4', '0.0###E0'), - 23341) - self.assertEqual(self.format.parse('4.100E01', '0.000##E00'), - 41) - self.assertEqual(self.format.parse('1E0', '0E0'), - 1) - self.assertEqual(self.format.parse('0E0', '0E0'), - 0) + self.assertEqual(self.format.parse('2.3341E4', '0.0###E0'), 23341) + self.assertEqual(self.format.parse('4.100E01', '0.000##E00'), 41) + self.assertEqual(self.format.parse('1E0', '0E0'), 1) + self.assertEqual(self.format.parse('0E0', '0E0'), 0) # This is a special case I found not working, but is used frequently # in the new LDML Locale files. - self.assertEqual(self.format.parse('2.3341E+04', '0.000###E+00'), - 23341) + self.assertEqual( + self.format.parse('2.3341E+04', '0.000###E+00'), 23341 + ) def testParsePosNegAlternativeInteger(self): - self.assertEqual(self.format.parse('23341', '#000;#00'), - 23341) - self.assertEqual(self.format.parse('041', '#000;#00'), - 41) - self.assertEqual(self.format.parse('41', '#000;#00'), - -41) - self.assertEqual(self.format.parse('01', '#000;#00'), - -1) + self.assertEqual(self.format.parse('23341', '#000;#00'), 23341) + self.assertEqual(self.format.parse('041', '#000;#00'), 41) + self.assertEqual(self.format.parse('41', '#000;#00'), -41) + self.assertEqual(self.format.parse('01', '#000;#00'), -1) def testParsePrefixedInteger(self): - self.assertEqual(self.format.parse('+23341', '+###0'), - 23341) - self.assertEqual(self.format.parse('+041', '+#000'), - 41) + self.assertEqual(self.format.parse('+23341', '+###0'), 23341) + self.assertEqual(self.format.parse('+041', '+#000'), 41) def testParsePosNegInteger(self): - self.assertEqual(self.format.parse('+23341', '+###0;-###0'), - 23341) - self.assertEqual(self.format.parse('+041', '+#000;-#000'), - 41) - self.assertEqual(self.format.parse('-23341', '+###0;-###0'), - -23341) - self.assertEqual(self.format.parse('-041', '+#000;-#000'), - -41) + self.assertEqual(self.format.parse('+23341', '+###0;-###0'), 23341) + self.assertEqual(self.format.parse('+041', '+#000;-#000'), 41) + self.assertEqual(self.format.parse('-23341', '+###0;-###0'), -23341) + self.assertEqual(self.format.parse('-041', '+#000;-#000'), -41) def testParseThousandSeparatorInteger(self): - self.assertEqual(self.format.parse('+23,341', '+#,##0;-#,##0'), - 23341) - self.assertEqual(self.format.parse('-23,341', '+#,##0;-#,##0'), - -23341) - self.assertEqual(self.format.parse('+0,041', '+#0,000;-#0,000'), - 41) - self.assertEqual(self.format.parse('-0,041', '+#0,000;-#0,000'), - -41) + self.assertEqual(self.format.parse('+23,341', '+#,##0;-#,##0'), 23341) + self.assertEqual(self.format.parse('-23,341', '+#,##0;-#,##0'), -23341) + self.assertEqual(self.format.parse('+0,041', '+#0,000;-#0,000'), 41) + self.assertEqual(self.format.parse('-0,041', '+#0,000;-#0,000'), -41) def testParseDecimal(self): - self.assertEqual(self.format.parse('23341.02', '###0.0#'), - 23341.02) - self.assertEqual(self.format.parse('23341.1', '###0.0#'), - 23341.1) - self.assertEqual(self.format.parse('23341.020', '###0.000#'), - 23341.02) + self.assertEqual(self.format.parse('23341.02', '###0.0#'), 23341.02) + self.assertEqual(self.format.parse('23341.1', '###0.0#'), 23341.1) + self.assertEqual(self.format.parse('23341.020', '###0.000#'), 23341.02) def testParseDecimalWithOptionalDecimalDigits(self): - self.assertEqual(self.format.parse('23341.02', '###0.##'), - 23341.02) - self.assertEqual(self.format.parse('23341', '###0.#'), - 23341.0) - self.assertEqual(self.format.parse('23341.', '###0.#'), - 23341.0) + self.assertEqual(self.format.parse('23341.02', '###0.##'), 23341.02) + self.assertEqual(self.format.parse('23341', '###0.#'), 23341.0) + self.assertEqual(self.format.parse('23341.', '###0.#'), 23341.0) def testParseScientificDecimal(self): - self.assertEqual(self.format.parse('2.334102E04', '0.00####E00'), - 23341.02) - self.assertEqual(self.format.parse('2.3341020E004', '0.0000000E000'), - 23341.02) - self.assertEqual(self.format.parse('0.0E0', '0.0#E0'), - 0.0) + self.assertEqual( + self.format.parse('2.334102E04', '0.00####E00'), 23341.02 + ) + self.assertEqual( + self.format.parse('2.3341020E004', '0.0000000E000'), 23341.02 + ) + self.assertEqual(self.format.parse('0.0E0', '0.0#E0'), 0.0) def testParseScientificDecimalSmallerOne(self): - self.assertEqual(self.format.parse('2.357E-02', '0.00####E00'), - 0.02357) - self.assertEqual(self.format.parse('2.0000E-02', '0.0000E00'), - 0.02) + self.assertEqual( + self.format.parse('2.357E-02', '0.00####E00'), 0.02357 + ) + self.assertEqual(self.format.parse('2.0000E-02', '0.0000E00'), 0.02) def testParsePadding1WithoutPrefix(self): - self.assertEqual(self.format.parse(' 41', '* ##0;*_##0'), - 41) - self.assertEqual(self.format.parse('_41', '* ##0;*_##0'), - -41) + self.assertEqual(self.format.parse(' 41', '* ##0;*_##0'), 41) + self.assertEqual(self.format.parse('_41', '* ##0;*_##0'), -41) def testParsePadding1WithPrefix(self): - self.assertEqual(self.format.parse(' +41', '* +##0;*_-##0'), - 41) - self.assertEqual(self.format.parse('_-41', '* +##0;*_-##0'), - -41) + self.assertEqual(self.format.parse(' +41', '* +##0;*_-##0'), 41) + self.assertEqual(self.format.parse('_-41', '* +##0;*_-##0'), -41) def testParsePadding1Padding2WithPrefix(self): - self.assertEqual(self.format.parse(' + 41', '* +* ###0;*_-*_###0'), - +41) - self.assertEqual(self.format.parse('__-_41', '* +* ###0;*_-*_###0'), - -41) + self.assertEqual( + self.format.parse(' + 41', '* +* ###0;*_-*_###0'), +41 + ) + self.assertEqual( + self.format.parse('__-_41', '* +* ###0;*_-*_###0'), -41 + ) def testParsePadding1Scientific(self): - self.assertEqual(self.format.parse(' 4.102E1', - '* 0.0####E0;*_0.0####E0'), - 41.02) - self.assertEqual(self.format.parse('__4.102E1', - '* 0.0####E0;*_0.0####E0'), - -41.02) - self.assertEqual(self.format.parse(' +4.102E1', - '* +0.0###E0;*_-0.0###E0'), - 41.02) - self.assertEqual(self.format.parse('_-4.102E1', - '* +0.0###E0;*_-0.0###E0'), - -41.02) + self.assertEqual( + self.format.parse(' 4.102E1', '* 0.0####E0;*_0.0####E0'), 41.02 + ) + self.assertEqual( + self.format.parse('__4.102E1', '* 0.0####E0;*_0.0####E0'), -41.02 + ) + self.assertEqual( + self.format.parse(' +4.102E1', '* +0.0###E0;*_-0.0###E0'), 41.02 + ) + self.assertEqual( + self.format.parse('_-4.102E1', '* +0.0###E0;*_-0.0###E0'), -41.02 + ) def testParsePadding3WithoutSufffix(self): - self.assertEqual(self.format.parse('41.02 ', '#0.0###* ;#0.0###*_'), - 41.02) - self.assertEqual(self.format.parse('41.02__', '#0.0###* ;#0.0###*_'), - -41.02) + self.assertEqual( + self.format.parse('41.02 ', '#0.0###* ;#0.0###*_'), 41.02 + ) + self.assertEqual( + self.format.parse('41.02__', '#0.0###* ;#0.0###*_'), -41.02 + ) def testParsePadding3WithSufffix(self): self.assertEqual( - self.format.parse('[41.02 ]', '[#0.0###* ];(#0.0###*_)'), - 41.02) + self.format.parse('[41.02 ]', '[#0.0###* ];(#0.0###*_)'), 41.02 + ) self.assertEqual( - self.format.parse('(41.02__)', '[#0.0###* ];(#0.0###*_)'), - -41.02) + self.format.parse('(41.02__)', '[#0.0###* ];(#0.0###*_)'), -41.02 + ) def testParsePadding3Scientific(self): - self.assertEqual(self.format.parse('4.102E1 ', - '0.0##E0##* ;0.0##E0##*_'), - 41.02) - self.assertEqual(self.format.parse('4.102E1__', - '0.0##E0##* ;0.0##E0##*_'), - -41.02) - self.assertEqual(self.format.parse('(4.102E1 )', - '(0.0##E0##* );0.0E0'), - 41.02) - self.assertEqual(self.format.parse('[4.102E1__]', - '0.0E0;[0.0##E0##*_]'), - -41.02) + self.assertEqual( + self.format.parse('4.102E1 ', '0.0##E0##* ;0.0##E0##*_'), 41.02 + ) + self.assertEqual( + self.format.parse('4.102E1__', '0.0##E0##* ;0.0##E0##*_'), -41.02 + ) + self.assertEqual( + self.format.parse('(4.102E1 )', '(0.0##E0##* );0.0E0'), 41.02 + ) + self.assertEqual( + self.format.parse('[4.102E1__]', '0.0E0;[0.0##E0##*_]'), -41.02 + ) def testParsePadding3Padding4WithSuffix(self): - self.assertEqual(self.format.parse('(41.02 ) ', '(#0.0###* )* '), - 41.02) - self.assertEqual(self.format.parse('(4.102E1 ) ', '(0.0##E0##* )* '), - 41.02) + self.assertEqual( + self.format.parse('(41.02 ) ', '(#0.0###* )* '), 41.02 + ) + self.assertEqual( + self.format.parse('(4.102E1 ) ', '(0.0##E0##* )* '), 41.02 + ) def testParseDecimalWithGermanDecimalSeparator(self): format = NumberFormat(symbols={'decimal': ',', 'group': '.'}) @@ -1210,7 +1575,8 @@ class TestNumberFormat(_TestCase): def testParseWithAlternativeExponentialSymbol(self): format = NumberFormat( - symbols={'decimal': '.', 'group': ',', 'exponential': 'X'}) + symbols={'decimal': '.', 'group': ',', 'exponential': 'X'} + ) self.assertEqual(format.parse('1.2X11', '#.#E0'), 1.2e11) def testParseFailWithInvalidCharacters(self): @@ -1232,112 +1598,94 @@ class TestNumberFormat(_TestCase): def testChangeOutputType(self): format = NumberFormat() format.type = decimal.Decimal - self.assertEqual(format.parse('23341', '###0'), - decimal.Decimal('23341')) - self.assertEqual(format.parse('233.41', '###0.00'), - decimal.Decimal('233.41')) + self.assertEqual( + format.parse('23341', '###0'), decimal.Decimal('23341') + ) + self.assertEqual( + format.parse('233.41', '###0.00'), decimal.Decimal('233.41') + ) def testFormatSimpleInteger(self): - self.assertEqual(self.format.format(23341, '###0'), - '23341') - self.assertEqual(self.format.format(41, '#000'), - '041') + self.assertEqual(self.format.format(23341, '###0'), '23341') + self.assertEqual(self.format.format(41, '#000'), '041') def testFormatScientificInteger(self): - self.assertEqual(self.format.format(23341, '0.000#E0'), - '2.3341E4') - self.assertEqual(self.format.format(23341, '0.000#E00'), - '2.3341E04') - self.assertEqual(self.format.format(1, '0.##E0'), - '1E0') - self.assertEqual(self.format.format(1, '0.00E00'), - '1.00E00') + self.assertEqual(self.format.format(23341, '0.000#E0'), '2.3341E4') + self.assertEqual(self.format.format(23341, '0.000#E00'), '2.3341E04') + self.assertEqual(self.format.format(1, '0.##E0'), '1E0') + self.assertEqual(self.format.format(1, '0.00E00'), '1.00E00') # This is a special case I found not working, but is used frequently # in the new LDML Locale files. - self.assertEqual(self.format.format(23341, '0.000###E+00'), - '2.3341E+04') + self.assertEqual( + self.format.format(23341, '0.000###E+00'), '2.3341E+04' + ) def testFormatScientificZero(self): - self.assertEqual(self.format.format(0, '0.00E00'), - '0.00E00') - self.assertEqual(self.format.format(0, '0E0'), - '0E0') + self.assertEqual(self.format.format(0, '0.00E00'), '0.00E00') + self.assertEqual(self.format.format(0, '0E0'), '0E0') def testFormatPosNegAlternativeInteger(self): - self.assertEqual(self.format.format(23341, '#000;#00'), - '23341') - self.assertEqual(self.format.format(41, '#000;#00'), - '041') - self.assertEqual(self.format.format(-23341, '#000;#00'), - '23341') - self.assertEqual(self.format.format(-41, '#000;#00'), - '41') - self.assertEqual(self.format.format(-1, '#000;#00'), - '01') + self.assertEqual(self.format.format(23341, '#000;#00'), '23341') + self.assertEqual(self.format.format(41, '#000;#00'), '041') + self.assertEqual(self.format.format(-23341, '#000;#00'), '23341') + self.assertEqual(self.format.format(-41, '#000;#00'), '41') + self.assertEqual(self.format.format(-1, '#000;#00'), '01') def testFormatPrefixedInteger(self): - self.assertEqual(self.format.format(23341, '+###0'), - '+23341') - self.assertEqual(self.format.format(41, '+#000'), - '+041') - self.assertEqual(self.format.format(-23341, '+###0'), - '+23341') - self.assertEqual(self.format.format(-41, '+#000'), - '+041') + self.assertEqual(self.format.format(23341, '+###0'), '+23341') + self.assertEqual(self.format.format(41, '+#000'), '+041') + self.assertEqual(self.format.format(-23341, '+###0'), '+23341') + self.assertEqual(self.format.format(-41, '+#000'), '+041') def testFormatPosNegInteger(self): - self.assertEqual(self.format.format(23341, '+###0;-###0'), - '+23341') - self.assertEqual(self.format.format(41, '+#000;-#000'), - '+041') - self.assertEqual(self.format.format(-23341, '+###0;-###0'), - '-23341') - self.assertEqual(self.format.format(-41, '+#000;-#000'), - '-041') + self.assertEqual(self.format.format(23341, '+###0;-###0'), '+23341') + self.assertEqual(self.format.format(41, '+#000;-#000'), '+041') + self.assertEqual(self.format.format(-23341, '+###0;-###0'), '-23341') + self.assertEqual(self.format.format(-41, '+#000;-#000'), '-041') def testFormatPosNegScientificInteger(self): - self.assertEqual(self.format.format(23341, '+0.00###E00;-0.00###E00'), - '+2.3341E04') - self.assertEqual(self.format.format(23341, '-0.00###E00;-0.00###E00'), - '-2.3341E04') - - def testFormatThousandSeparatorInteger(self): - self.assertEqual( - self.format.format(23341, '+#,##0;-#,##0'), - '+23,341') self.assertEqual( - self.format.format(-23341, '+#,##0;-#,##0'), - '-23,341') + self.format.format(23341, '+0.00###E00;-0.00###E00'), '+2.3341E04' + ) self.assertEqual( - self.format.format(41, '+#0,000;-#0,000'), - '+0,041') + self.format.format(23341, '-0.00###E00;-0.00###E00'), '-2.3341E04' + ) + + def testFormatThousandSeparatorInteger(self): + self.assertEqual(self.format.format(23341, '+#,##0;-#,##0'), '+23,341') self.assertEqual( - self.format.format(-41, '+#0,000;-#0,000'), - '-0,041') + self.format.format(-23341, '+#,##0;-#,##0'), '-23,341' + ) + self.assertEqual(self.format.format(41, '+#0,000;-#0,000'), '+0,041') + self.assertEqual(self.format.format(-41, '+#0,000;-#0,000'), '-0,041') self.assertEqual( - self.format.format(987654321, '+#,##0;-#,##0'), - '+987,654,321') + self.format.format(987654321, '+#,##0;-#,##0'), '+987,654,321' + ) self.assertEqual( - self.format.format(-987654321, '+#,##0;-#,##0'), - '-987,654,321') + self.format.format(-987654321, '+#,##0;-#,##0'), '-987,654,321' + ) self.assertEqual( self.format.format(987654321, '+#,##,#0,000;-#,##,#0,000'), - '+98,76,54,321') + '+98,76,54,321', + ) self.assertEqual( self.format.format(-987654321, '+#,##,#0,000;-#,##,#0,000'), - '-98,76,54,321') + '-98,76,54,321', + ) def testFormatBadThousandSeparator(self): - self.assertRaises(ValueError, - self.format.format, 23341, '0,') + self.assertRaises(ValueError, self.format.format, 23341, '0,') def testFormatDecimal(self): - self.assertEqual(self.format.format(23341.02357, '###0.0#'), - '23341.02') - self.assertEqual(self.format.format(23341.02357, '###0.000#'), - '23341.0236') - self.assertEqual(self.format.format(23341.02, '###0.000#'), - '23341.020') + self.assertEqual( + self.format.format(23341.02357, '###0.0#'), '23341.02' + ) + self.assertEqual( + self.format.format(23341.02357, '###0.000#'), '23341.0236' + ) + self.assertEqual( + self.format.format(23341.02, '###0.000#'), '23341.020' + ) def testRounding(self): self.assertEqual(self.format.format(0.5, '#'), '1') @@ -1348,110 +1696,126 @@ class TestNumberFormat(_TestCase): self.assertEqual(self.format.format(1.9999, '0.000'), '2.000') self.assertEqual(self.format.format(1.9999, '0.0000'), '1.9999') - def testFormatScientificDecimal(self): - self.assertEqual(self.format.format(23341.02357, '0.00####E00'), - '2.334102E04') - self.assertEqual(self.format.format(23341.02, '0.0000000E000'), - '2.3341020E004') + self.assertEqual( + self.format.format(23341.02357, '0.00####E00'), '2.334102E04' + ) + self.assertEqual( + self.format.format(23341.02, '0.0000000E000'), '2.3341020E004' + ) def testFormatScientificDecimalSmallerOne(self): - self.assertEqual(self.format.format(0.02357, '0.00####E00'), - '2.357E-02') - self.assertEqual(self.format.format(0.02, '0.0000E00'), - '2.0000E-02') + self.assertEqual( + self.format.format(0.02357, '0.00####E00'), '2.357E-02' + ) + self.assertEqual(self.format.format(0.02, '0.0000E00'), '2.0000E-02') def testFormatPadding1WithoutPrefix(self): - self.assertEqual(self.format.format(41, '* ##0;*_##0'), - ' 41') - self.assertEqual(self.format.format(-41, '* ##0;*_##0'), - '_41') + self.assertEqual(self.format.format(41, '* ##0;*_##0'), ' 41') + self.assertEqual(self.format.format(-41, '* ##0;*_##0'), '_41') def testFormatPadding1WithPrefix(self): - self.assertEqual(self.format.format(41, '* +##0;*_-##0'), - ' +41') - self.assertEqual(self.format.format(-41, '* +##0;*_-##0'), - '_-41') + self.assertEqual(self.format.format(41, '* +##0;*_-##0'), ' +41') + self.assertEqual(self.format.format(-41, '* +##0;*_-##0'), '_-41') def testFormatPadding1Scientific(self): - self.assertEqual(self.format.format(41.02, '* 0.0####E0;*_0.0####E0'), - ' 4.102E1') - self.assertEqual(self.format.format(-41.02, '* 0.0####E0;*_0.0####E0'), - '__4.102E1') - self.assertEqual(self.format.format(41.02, '* +0.0###E0;*_-0.0###E0'), - ' +4.102E1') - self.assertEqual(self.format.format(-41.02, '* +0.0###E0;*_-0.0###E0'), - '_-4.102E1') + self.assertEqual( + self.format.format(41.02, '* 0.0####E0;*_0.0####E0'), ' 4.102E1' + ) + self.assertEqual( + self.format.format(-41.02, '* 0.0####E0;*_0.0####E0'), '__4.102E1' + ) + self.assertEqual( + self.format.format(41.02, '* +0.0###E0;*_-0.0###E0'), ' +4.102E1' + ) + self.assertEqual( + self.format.format(-41.02, '* +0.0###E0;*_-0.0###E0'), '_-4.102E1' + ) def testFormatPadding1Padding2WithPrefix(self): - self.assertEqual(self.format.format(41, '* +* ###0;*_-*_###0'), - ' + 41') - self.assertEqual(self.format.format(-41, '* +* ###0;*_-*_###0'), - '__-_41') + self.assertEqual( + self.format.format(41, '* +* ###0;*_-*_###0'), ' + 41' + ) + self.assertEqual( + self.format.format(-41, '* +* ###0;*_-*_###0'), '__-_41' + ) def testFormatPadding3WithoutSufffix(self): - self.assertEqual(self.format.format(41.02, '#0.0###* ;#0.0###*_'), - '41.02 ') - self.assertEqual(self.format.format(-41.02, '#0.0###* ;#0.0###*_'), - '41.02__') + self.assertEqual( + self.format.format(41.02, '#0.0###* ;#0.0###*_'), '41.02 ' + ) + self.assertEqual( + self.format.format(-41.02, '#0.0###* ;#0.0###*_'), '41.02__' + ) def testFormatPadding3WithSufffix(self): - self.assertEqual(self.format.format(41.02, '[#0.0###* ];(#0.0###*_)'), - '[41.02 ]') - self.assertEqual(self.format.format(-41.02, '[#0.0###* ];(#0.0###*_)'), - '(41.02__)') + self.assertEqual( + self.format.format(41.02, '[#0.0###* ];(#0.0###*_)'), '[41.02 ]' + ) + self.assertEqual( + self.format.format(-41.02, '[#0.0###* ];(#0.0###*_)'), '(41.02__)' + ) def testFormatPadding3Scientific(self): - self.assertEqual(self.format.format(41.02, '0.0##E0##* ;0.0##E0##*_'), - '4.102E1 ') - self.assertEqual(self.format.format(-41.02, '0.0##E0##* ;0.0##E0##*_'), - '4.102E1__') - self.assertEqual(self.format.format(41.02, '(0.0##E0##* );0.0E0'), - '(4.102E1 )') - self.assertEqual(self.format.format(-41.02, '0.0E0;[0.0##E0##*_]'), - '[4.102E1__]') + self.assertEqual( + self.format.format(41.02, '0.0##E0##* ;0.0##E0##*_'), '4.102E1 ' + ) + self.assertEqual( + self.format.format(-41.02, '0.0##E0##* ;0.0##E0##*_'), '4.102E1__' + ) + self.assertEqual( + self.format.format(41.02, '(0.0##E0##* );0.0E0'), '(4.102E1 )' + ) + self.assertEqual( + self.format.format(-41.02, '0.0E0;[0.0##E0##*_]'), '[4.102E1__]' + ) def testFormatPadding3Padding4WithSuffix(self): - self.assertEqual(self.format.format(41.02, '(#0.0###* )* '), - '(41.02 ) ') - self.assertEqual(self.format.format(41.02, '(0.0##E0##* )* '), - '(4.102E1 ) ') + self.assertEqual( + self.format.format(41.02, '(#0.0###* )* '), '(41.02 ) ' + ) + self.assertEqual( + self.format.format(41.02, '(0.0##E0##* )* '), '(4.102E1 ) ' + ) def testFormatSmallNumbers(self): - self.assertEqual(self.format.format( - -1e-7, '(#0.00#####);(-#0.00#####)'), '(-0.0000001)') + self.assertEqual( + self.format.format(-1e-7, '(#0.00#####);(-#0.00#####)'), + '(-0.0000001)', + ) self.assertEqual(self.format.format(1e-9, '(#0.00###)'), '(0.00)') self.assertEqual(self.format.format(1e-9, '(#0.00###)'), '(0.00)') def testFormatHighPrecisionNumbers(self): self.assertEqual( - self.format.format( - 1+1e-7, '(#0.00#####);(-#0.00#####)'), - '(1.0000001)') + self.format.format(1 + 1e-7, '(#0.00#####);(-#0.00#####)'), + '(1.0000001)', + ) self.assertEqual( - self.format.format( - 1+1e-7, '(#0.00###)'), - '(1.00000)') + self.format.format(1 + 1e-7, '(#0.00###)'), '(1.00000)' + ) self.assertEqual( - self.format.format( - 1+1e-9, '(#0.00#######);(-#0.00#######)'), - '(1.000000001)') + self.format.format(1 + 1e-9, '(#0.00#######);(-#0.00#######)'), + '(1.000000001)', + ) self.assertEqual( - self.format.format( - 1+1e-9, '(#0.00###)'), - '(1.00000)') + self.format.format(1 + 1e-9, '(#0.00###)'), '(1.00000)' + ) self.assertEqual( self.format.format( - 1+1e-12, '(#0.00##########);(-#0.00##########)'), - '(1.000000000001)') + 1 + 1e-12, '(#0.00##########);(-#0.00##########)' + ), + '(1.000000000001)', + ) self.assertEqual( - self.format.format( - 1+1e-12, '(#0.00###)'), - '(1.00000)') + self.format.format(1 + 1e-12, '(#0.00###)'), '(1.00000)' + ) def testNoRounding(self): # Witout Rounding self.assertEqual( self.format.format( - decimal.Decimal('0.99999'), '0.###', rounding=False), - '0.99999') + decimal.Decimal('0.99999'), '0.###', rounding=False + ), + '0.99999', + ) diff --git a/src/zope/i18n/tests/test_gettextmessagecatalog.py b/src/zope/i18n/tests/test_gettextmessagecatalog.py index 07a0932..3160c97 100644 --- a/src/zope/i18n/tests/test_gettextmessagecatalog.py +++ b/src/zope/i18n/tests/test_gettextmessagecatalog.py @@ -19,14 +19,13 @@ from zope.i18n.tests import test_imessagecatalog class GettextMessageCatalogTest(test_imessagecatalog.TestIMessageCatalog): - def _getMessageCatalog(self): from zope.i18n import tests + path = os.path.dirname(tests.__file__) self._path = os.path.join(path, 'en-default.mo') catalog = GettextMessageCatalog('en', 'default', self._path) return catalog - def _getUniqueIndentifier(self): return self._path diff --git a/src/zope/i18n/tests/test_imessagecatalog.py b/src/zope/i18n/tests/test_imessagecatalog.py index 803d4f0..36fb43c 100644 --- a/src/zope/i18n/tests/test_imessagecatalog.py +++ b/src/zope/i18n/tests/test_imessagecatalog.py @@ -21,7 +21,6 @@ from zope.schema import getValidationErrors class TestIMessageCatalog(unittest.TestCase): - # This should be overridden by every class that inherits this test def _getMessageCatalog(self): raise NotImplementedError() @@ -29,7 +28,6 @@ class TestIMessageCatalog(unittest.TestCase): def _getUniqueIndentifier(self): raise NotImplementedError() - def setUp(self): self._catalog = self._getMessageCatalog() @@ -63,4 +61,4 @@ class TestIMessageCatalog(unittest.TestCase): def test_suite(): - return unittest.TestSuite() # Deliberately empty + return unittest.TestSuite() # Deliberately empty diff --git a/src/zope/i18n/tests/test_itranslationdomain.py b/src/zope/i18n/tests/test_itranslationdomain.py index 79c385f..e061d87 100644 --- a/src/zope/i18n/tests/test_itranslationdomain.py +++ b/src/zope/i18n/tests/test_itranslationdomain.py @@ -28,16 +28,16 @@ from zope.i18n.interfaces import ITranslationDomain text_type = str if bytes is not str else unicode + @implementer(IUserPreferredLanguages) class Environment(object): - - def __init__(self, langs=()): self.langs = langs def getPreferredLanguages(self): return self.langs + class TestITranslationDomain(PlacelessSetup): # This should be overwritten by every class that inherits this test @@ -70,25 +70,40 @@ class TestITranslationDomain(PlacelessSetup): translate = self._domain.translate eq = self.assertEqual # Testing both translation and interpolation - eq(translate('greeting', mapping={'name': 'Stephan'}, - target_language='de'), - 'Hallo Stephan, wie geht es Dir?') + eq( + translate( + 'greeting', mapping={'name': 'Stephan'}, target_language='de' + ), + 'Hallo Stephan, wie geht es Dir?', + ) # Testing default value interpolation - eq(translate('greeting', mapping={'name': 'Philipp'}, - target_language='fr', - default="Hello $name, how are you?"), - 'Hello Philipp, how are you?') + eq( + translate( + 'greeting', + mapping={'name': 'Philipp'}, + target_language='fr', + default="Hello $name, how are you?", + ), + 'Hello Philipp, how are you?', + ) def testNoTranslation(self): translate = self._domain.translate eq = self.assertEqual # Verify that an unknown message id will end up not being translated - eq(translate('glorp_smurf_hmpf', target_language='en'), - 'glorp_smurf_hmpf') + eq( + translate('glorp_smurf_hmpf', target_language='en'), + 'glorp_smurf_hmpf', + ) # Test default value behaviour - eq(translate('glorp_smurf_hmpf', target_language='en', - default='Glorp Smurf Hmpf'), - 'Glorp Smurf Hmpf') + eq( + translate( + 'glorp_smurf_hmpf', + target_language='en', + default='Glorp Smurf Hmpf', + ), + 'Glorp Smurf Hmpf', + ) def testUnicodeDefaultValue(self): translate = self._domain.translate @@ -100,7 +115,7 @@ class TestITranslationDomain(PlacelessSetup): translate = self._domain.translate eq = self.assertEqual # Test that default is returned when no language can be negotiated - context = Environment(('xx', )) + context = Environment(('xx',)) eq(translate('short_greeting', context=context, default=42), 42) # Test that default is returned when there's no destination language @@ -108,4 +123,4 @@ class TestITranslationDomain(PlacelessSetup): def test_suite(): - return unittest.TestSuite() # Deliberately empty + return unittest.TestSuite() # Deliberately empty diff --git a/src/zope/i18n/tests/test_negotiator.py b/src/zope/i18n/tests/test_negotiator.py index f8a0336..d78218e 100644 --- a/src/zope/i18n/tests/test_negotiator.py +++ b/src/zope/i18n/tests/test_negotiator.py @@ -20,9 +20,9 @@ from zope.i18n.interfaces import IUserPreferredLanguages from zope.component.testing import PlacelessSetup from zope.interface import implementer + @implementer(IUserPreferredLanguages) class Env(object): - def __init__(self, langs=()): self.langs = langs @@ -31,7 +31,6 @@ class Env(object): class NegotiatorTest(PlacelessSetup, unittest.TestCase): - def setUp(self): super(NegotiatorTest, self).setUp() self.negotiator = Negotiator() @@ -39,23 +38,23 @@ class NegotiatorTest(PlacelessSetup, unittest.TestCase): def test_findLanguages(self): _cases = ( - (('en','de'), ('en','de','fr'), 'en'), - (('en'), ('it','de','fr'), None), - (('pt-br','de'), ('pt_BR','de','fr'), 'pt_BR'), - (('pt-br','en'), ('pt', 'en', 'fr'), 'pt'), - (('pt-br','en-us', 'de'), ('de', 'en', 'fr'), 'en'), - ) + (('en', 'de'), ('en', 'de', 'fr'), 'en'), + (('en'), ('it', 'de', 'fr'), None), + (('pt-br', 'de'), ('pt_BR', 'de', 'fr'), 'pt_BR'), + (('pt-br', 'en'), ('pt', 'en', 'fr'), 'pt'), + (('pt-br', 'en-us', 'de'), ('de', 'en', 'fr'), 'en'), + ) for user_pref_langs, obj_langs, expected in _cases: env = Env(user_pref_langs) - self.assertEqual(self.negotiator.getLanguage(obj_langs, env), - expected) + self.assertEqual( + self.negotiator.getLanguage(obj_langs, env), expected + ) def test_suite(): - return unittest.TestSuite(( - unittest.makeSuite(NegotiatorTest), - )) + return unittest.TestSuite((unittest.makeSuite(NegotiatorTest),)) + if __name__ == '__main__': unittest.main(defaultTest='test_suite') diff --git a/src/zope/i18n/tests/test_plurals.py b/src/zope/i18n/tests/test_plurals.py index d4f57c7..76f1823 100644 --- a/src/zope/i18n/tests/test_plurals.py +++ b/src/zope/i18n/tests/test_plurals.py @@ -26,7 +26,6 @@ from zope.i18n.interfaces import ITranslationDomain class TestPlurals(unittest.TestCase): - def _getMessageCatalog(self, locale, variant="default"): path = os.path.dirname(tests.__file__) self._path = os.path.join(path, '%s-%s.mo' % (locale, variant)) @@ -47,21 +46,32 @@ class TestPlurals(unittest.TestCase): self.assertEqual( catalog.queryPluralMessage( - 'One apple', '%d apples', 0, - dft1='One fruit', dft2='%d fruits'), - '0 fruits') + 'One apple', '%d apples', 0, dft1='One fruit', dft2='%d fruits' + ), + '0 fruits', + ) self.assertEqual( catalog.queryPluralMessage( - 'One apple.', '%d apples.', 1, - dft1='One fruit', dft2='%d fruits'), - 'One fruit') + 'One apple.', + '%d apples.', + 1, + dft1='One fruit', + dft2='%d fruits', + ), + 'One fruit', + ) self.assertEqual( catalog.queryPluralMessage( - 'One apple.', '%d apples.', 2, - dft1='One fruit', dft2='%d fruits'), - '2 fruits') + 'One apple.', + '%d apples.', + 2, + dft1='One fruit', + dft2='%d fruits', + ), + '2 fruits', + ) def test_missing_getPluralMessage(self): catalog = self._getMessageCatalog('en') @@ -83,37 +93,65 @@ class TestPlurals(unittest.TestCase): catalog = self._getMessageCatalog('de') self.assertEqual(catalog.language, 'de') - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 1), - 'Es gibt eine Datei.') - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 3), - 'Es gibt 3 Dateien.') - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 0), - 'Es gibt 0 Dateien.') + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 1 + ), + 'Es gibt eine Datei.', + ) + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 3 + ), + 'Es gibt 3 Dateien.', + ) + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 0 + ), + 'Es gibt 0 Dateien.', + ) # Unknown id - self.assertRaises(KeyError, catalog.getPluralMessage, - 'There are %d files.', 'bar', 6) + self.assertRaises( + KeyError, catalog.getPluralMessage, 'There are %d files.', 'bar', 6 + ) # Query without default values - self.assertEqual(catalog.queryPluralMessage( - 'There is one file.', 'There are %d files.', 1), - 'Es gibt eine Datei.') - self.assertEqual(catalog.queryPluralMessage( - 'There is one file.', 'There are %d files.', 3), - 'Es gibt 3 Dateien.') + self.assertEqual( + catalog.queryPluralMessage( + 'There is one file.', 'There are %d files.', 1 + ), + 'Es gibt eine Datei.', + ) + self.assertEqual( + catalog.queryPluralMessage( + 'There is one file.', 'There are %d files.', 3 + ), + 'Es gibt 3 Dateien.', + ) # Query with default values - self.assertEqual(catalog.queryPluralMessage( - 'There are %d files.', 'There is one file.', 1, - 'Es gibt 1 Datei.', 'Es gibt %d Dateien !', ), - 'Es gibt 1 Datei.') - self.assertEqual(catalog.queryPluralMessage( - 'There are %d files.', 'There is one file.', 3, - 'Es gibt 1 Datei.', 'Es gibt %d Dateien !', ), - 'Es gibt 3 Dateien !') + self.assertEqual( + catalog.queryPluralMessage( + 'There are %d files.', + 'There is one file.', + 1, + 'Es gibt 1 Datei.', + 'Es gibt %d Dateien !', + ), + 'Es gibt 1 Datei.', + ) + self.assertEqual( + catalog.queryPluralMessage( + 'There are %d files.', + 'There is one file.', + 3, + 'Es gibt 1 Datei.', + 'Es gibt %d Dateien !', + ), + 'Es gibt 3 Dateien !', + ) def test_PolishPlurals(self): """Polish has a complex rule for plurals. It makes for a good @@ -122,24 +160,42 @@ class TestPlurals(unittest.TestCase): catalog = self._getMessageCatalog('pl') self.assertEqual(catalog.language, 'pl') - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 0), - u"Istnieją 0 plików.") - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 1), - u"Istnieje 1 plik.") - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 3), - u"Istnieją 3 pliki.") - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 17), - u"Istnieją 17 plików.") - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 23), - u"Istnieją 23 pliki.") - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 28), - u"Istnieją 28 plików.") + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 0 + ), + u"Istnieją 0 plików.", + ) + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 1 + ), + u"Istnieje 1 plik.", + ) + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 3 + ), + u"Istnieją 3 pliki.", + ) + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 17 + ), + u"Istnieją 17 plików.", + ) + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 23 + ), + u"Istnieją 23 pliki.", + ) + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 28 + ), + u"Istnieją 28 plików.", + ) def test_floater(self): """Test with the number being a float. @@ -149,101 +205,175 @@ class TestPlurals(unittest.TestCase): self.assertEqual(catalog.language, 'en') # It's cast to integer because of the %d in the translation string. - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 1.0), - 'There is one file.') - self.assertEqual(catalog.getPluralMessage( - 'There is one file.', 'There are %d files.', 3.5), - 'There are 3 files.') + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 1.0 + ), + 'There is one file.', + ) + self.assertEqual( + catalog.getPluralMessage( + 'There is one file.', 'There are %d files.', 3.5 + ), + 'There are 3 files.', + ) # It's cast to a string because of the %s in the translation string. - self.assertEqual(catalog.getPluralMessage( - 'The item is rated 1/5 star.', - 'The item is rated %s/5 stars.', 3.5), - 'The item is rated 3.5/5 stars.') + self.assertEqual( + catalog.getPluralMessage( + 'The item is rated 1/5 star.', + 'The item is rated %s/5 stars.', + 3.5, + ), + 'The item is rated 3.5/5 stars.', + ) # It's cast either to an int or a float because of the %s in # the translation string. - self.assertEqual(catalog.getPluralMessage( - 'There is %d chance.', - 'There are %f chances.', 1.5), - 'There are 1.500000 chances.') - self.assertEqual(catalog.getPluralMessage( - 'There is %d chance.', - 'There are %f chances.', 3.5), - 'There are 3.500000 chances.') + self.assertEqual( + catalog.getPluralMessage( + 'There is %d chance.', 'There are %f chances.', 1.5 + ), + 'There are 1.500000 chances.', + ) + self.assertEqual( + catalog.getPluralMessage( + 'There is %d chance.', 'There are %f chances.', 3.5 + ), + 'There are 3.500000 chances.', + ) def test_translate_without_defaults(self): domain = self._getTranslationDomain('en') zope.component.provideUtility(domain, ITranslationDomain, 'default') self.assertEqual( - translate('One apple', domain='default', - msgid_plural='%d apples', number=0), - '0 apples') + translate( + 'One apple', + domain='default', + msgid_plural='%d apples', + number=0, + ), + '0 apples', + ) self.assertEqual( - translate('One apple', domain='default', - msgid_plural='%d apples', number=1), - 'One apple') + translate( + 'One apple', + domain='default', + msgid_plural='%d apples', + number=1, + ), + 'One apple', + ) self.assertEqual( - translate('One apple', domain='default', - msgid_plural='%d apples', number=2), - '2 apples') + translate( + 'One apple', + domain='default', + msgid_plural='%d apples', + number=2, + ), + '2 apples', + ) def test_translate_with_defaults(self): domain = self._getTranslationDomain('en') zope.component.provideUtility(domain, ITranslationDomain, 'default') self.assertEqual( - translate('One apple', domain='default', - msgid_plural='%d apples', number=0, - default='One fruit', default_plural='%d fruits'), - '0 fruits') + translate( + 'One apple', + domain='default', + msgid_plural='%d apples', + number=0, + default='One fruit', + default_plural='%d fruits', + ), + '0 fruits', + ) self.assertEqual( - translate('One apple', domain='default', - msgid_plural='%d apples', number=1, - default='One fruit', default_plural='%d fruits'), - 'One fruit') + translate( + 'One apple', + domain='default', + msgid_plural='%d apples', + number=1, + default='One fruit', + default_plural='%d fruits', + ), + 'One fruit', + ) self.assertEqual( - translate('One apple', domain='default', - msgid_plural='%d apples', number=2, - default='One fruit', default_plural='%d fruits'), - '2 fruits') + translate( + 'One apple', + domain='default', + msgid_plural='%d apples', + number=2, + default='One fruit', + default_plural='%d fruits', + ), + '2 fruits', + ) def test_translate_message_without_defaults(self): domain = self._getTranslationDomain('en') factory = MessageFactory('default') zope.component.provideUtility(domain, ITranslationDomain, 'default') self.assertEqual( - translate(factory('One apple', msgid_plural='%d apples', - number=0)), - '0 apples') + translate( + factory('One apple', msgid_plural='%d apples', number=0) + ), + '0 apples', + ) self.assertEqual( - translate(factory('One apple', msgid_plural='%d apples', - number=1)), - 'One apple') + translate( + factory('One apple', msgid_plural='%d apples', number=1) + ), + 'One apple', + ) self.assertEqual( - translate(factory('One apple', msgid_plural='%d apples', - number=2)), - '2 apples') + translate( + factory('One apple', msgid_plural='%d apples', number=2) + ), + '2 apples', + ) def test_translate_message_with_defaults(self): domain = self._getTranslationDomain('en') factory = MessageFactory('default') zope.component.provideUtility(domain, ITranslationDomain, 'default') self.assertEqual( - translate(factory('One apple', msgid_plural='%d apples', number=0, - default='One fruit', - default_plural='%d fruits')), - '0 fruits') + translate( + factory( + 'One apple', + msgid_plural='%d apples', + number=0, + default='One fruit', + default_plural='%d fruits', + ) + ), + '0 fruits', + ) self.assertEqual( - translate(factory('One apple', msgid_plural='%d apples', number=1, - default='One fruit', - default_plural='%d fruits')), - 'One fruit') + translate( + factory( + 'One apple', + msgid_plural='%d apples', + number=1, + default='One fruit', + default_plural='%d fruits', + ) + ), + 'One fruit', + ) self.assertEqual( - translate(factory('One apple', msgid_plural='%d apples', number=2, - default='One fruit', - default_plural='%d fruits')), - '2 fruits') + translate( + factory( + 'One apple', + msgid_plural='%d apples', + number=2, + default='One fruit', + default_plural='%d fruits', + ) + ), + '2 fruits', + ) def test_translate_recursive(self): domain = self._getTranslationDomain('en') @@ -251,30 +381,42 @@ class TestPlurals(unittest.TestCase): # Singular banana = factory('banana', msgid_plural='bananas', number=1) - phrase = factory('There is %d ${type}.', - msgid_plural='There are %d ${type}.', - number=1, mapping={'type': banana}) + phrase = factory( + 'There is %d ${type}.', + msgid_plural='There are %d ${type}.', + number=1, + mapping={'type': banana}, + ) self.assertEqual( domain.translate(phrase, target_language="en"), - 'There is 1 banana.') + 'There is 1 banana.', + ) # Plural apple = factory('apple', msgid_plural='apples', number=10) - phrase = factory('There is %d ${type}.', - msgid_plural='There are %d ${type}.', - number=10, mapping={'type': apple}) + phrase = factory( + 'There is %d ${type}.', + msgid_plural='There are %d ${type}.', + number=10, + mapping={'type': apple}, + ) self.assertEqual( domain.translate(phrase, target_language="en"), - 'There are 10 apples.') + 'There are 10 apples.', + ) # Straight translation with translatable mapping apple = factory('apple', msgid_plural='apples', number=75) self.assertEqual( - domain.translate(msgid='There is %d ${type}.', - msgid_plural='There are %d ${type}.', - mapping={'type': apple}, - target_language="en", number=75), - 'There are 75 apples.') + domain.translate( + msgid='There is %d ${type}.', + msgid_plural='There are %d ${type}.', + mapping={'type': apple}, + target_language="en", + number=75, + ), + 'There are 75 apples.', + ) # Add another catalog, to test the domain's catalogs iteration # We add this catalog in first position, to resolve the translations @@ -285,8 +427,12 @@ class TestPlurals(unittest.TestCase): apple = factory('apple', msgid_plural='apples', number=42) self.assertEqual( - domain.translate(msgid='There is %d ${type}.', - msgid_plural='There are %d ${type}.', - mapping={'type': apple}, - target_language="de", number=42), - 'There are 42 oranges.') + domain.translate( + msgid='There is %d ${type}.', + msgid_plural='There are %d ${type}.', + mapping={'type': apple}, + target_language="de", + number=42, + ), + 'There are 42 oranges.', + ) diff --git a/src/zope/i18n/tests/test_simpletranslationdomain.py b/src/zope/i18n/tests/test_simpletranslationdomain.py index 7c87c40..eabf2a1 100644 --- a/src/zope/i18n/tests/test_simpletranslationdomain.py +++ b/src/zope/i18n/tests/test_simpletranslationdomain.py @@ -22,11 +22,11 @@ data = { ('en', 'short_greeting'): 'Hello!', ('de', 'short_greeting'): 'Hallo!', ('en', 'greeting'): 'Hello $name, how are you?', - ('de', 'greeting'): 'Hallo $name, wie geht es Dir?'} + ('de', 'greeting'): 'Hallo $name, wie geht es Dir?', +} class TestSimpleTranslationDomain(unittest.TestCase, TestITranslationDomain): - def setUp(self): TestITranslationDomain.setUp(self) diff --git a/src/zope/i18n/tests/test_testmessagecatalog.py b/src/zope/i18n/tests/test_testmessagecatalog.py index ce5adc6..e90ac1a 100644 --- a/src/zope/i18n/tests/test_testmessagecatalog.py +++ b/src/zope/i18n/tests/test_testmessagecatalog.py @@ -15,10 +15,12 @@ import unittest import doctest + def test_suite(): - return unittest.TestSuite(( - doctest.DocFileSuite('../testmessagecatalog.rst') - )) + return unittest.TestSuite( + (doctest.DocFileSuite('../testmessagecatalog.rst')) + ) + if __name__ == '__main__': unittest.main(defaultTest='test_suite') diff --git a/src/zope/i18n/tests/test_translationdomain.py b/src/zope/i18n/tests/test_translationdomain.py index f8efbd9..4687107 100644 --- a/src/zope/i18n/tests/test_translationdomain.py +++ b/src/zope/i18n/tests/test_translationdomain.py @@ -17,8 +17,10 @@ import unittest import os from zope.i18n.translationdomain import TranslationDomain from zope.i18n.gettextmessagecatalog import GettextMessageCatalog -from zope.i18n.tests.test_itranslationdomain import \ - TestITranslationDomain, Environment +from zope.i18n.tests.test_itranslationdomain import ( + TestITranslationDomain, + Environment, +) from zope.i18nmessageid import MessageFactory from zope.i18n.interfaces import ITranslationDomain @@ -31,13 +33,10 @@ de_file = os.path.join(testdir, 'de-default.mo') class TestGlobalTranslationDomain(TestITranslationDomain, unittest.TestCase): - def _getTranslationDomain(self): domain = TranslationDomain('default') - en_catalog = GettextMessageCatalog('en', 'default', - en_file) - de_catalog = GettextMessageCatalog('de', 'default', - de_file) + en_catalog = GettextMessageCatalog('en', 'default', en_file) + de_catalog = GettextMessageCatalog('de', 'default', de_file) domain.addCatalog(en_catalog) domain.addCatalog(de_catalog) return domain @@ -56,14 +55,24 @@ class TestGlobalTranslationDomain(TestITranslationDomain, unittest.TestCase): # Test that a translation in an unsupported language returns the # default, if there is no fallback language eq(translate('short_greeting', target_language='es'), 'short_greeting') - eq(translate('short_greeting', target_language='es', - default='short_greeting'), 'short_greeting') + eq( + translate( + 'short_greeting', + target_language='es', + default='short_greeting', + ), + 'short_greeting', + ) # Same test, but use the context argument instead of target_language context = Environment() eq(translate('short_greeting', context=context), 'short_greeting') - eq(translate('short_greeting', context=context, - default='short_greeting'), 'short_greeting') + eq( + translate( + 'short_greeting', context=context, default='short_greeting' + ), + 'short_greeting', + ) def testEmptyStringTranslate(self): translate = self._domain.translate @@ -73,7 +82,8 @@ class TestGlobalTranslationDomain(TestITranslationDomain, unittest.TestCase): def testStringTranslate(self): self.assertEqual( self._domain.translate(u"short_greeting", target_language='en'), - u"Hello!") + u"Hello!", + ) def testMessageIDTranslate(self): factory = MessageFactory('default') @@ -81,44 +91,58 @@ class TestGlobalTranslationDomain(TestITranslationDomain, unittest.TestCase): msgid = factory(u"short_greeting", 'default') self.assertEqual(translate(msgid, target_language='en'), u"Hello!") # MessageID attributes override arguments - msgid = factory('43-not-there', 'this ${that} the other', - mapping={'that': 'THAT'}) + msgid = factory( + '43-not-there', 'this ${that} the other', mapping={'that': 'THAT'} + ) self.assertEqual( - translate(msgid, target_language='en', default="default", - mapping={"that": "that"}), "this THAT the other") + translate( + msgid, + target_language='en', + default="default", + mapping={"that": "that"}, + ), + "this THAT the other", + ) def testMessageIDRecursiveTranslate(self): factory = MessageFactory('default') translate = self._domain.translate - msgid_sub1 = factory(u"44-not-there", '${blue}', - mapping={'blue': 'BLUE'}) - msgid_sub2 = factory(u"45-not-there", '${yellow}', - mapping={'yellow': 'YELLOW'}) - mapping = {'color1': msgid_sub1, - 'color2': msgid_sub2} - msgid = factory(u"46-not-there", 'Color: ${color1}/${color2}', - mapping=mapping) + msgid_sub1 = factory( + u"44-not-there", '${blue}', mapping={'blue': 'BLUE'} + ) + msgid_sub2 = factory( + u"45-not-there", '${yellow}', mapping={'yellow': 'YELLOW'} + ) + mapping = {'color1': msgid_sub1, 'color2': msgid_sub2} + msgid = factory( + u"46-not-there", 'Color: ${color1}/${color2}', mapping=mapping + ) self.assertEqual( translate(msgid, target_language='en', default="default"), - "Color: BLUE/YELLOW") + "Color: BLUE/YELLOW", + ) # The recursive translation must not change the mappings - self.assertEqual(msgid.mapping, {'color1': msgid_sub1, - 'color2': msgid_sub2}) + self.assertEqual( + msgid.mapping, {'color1': msgid_sub1, 'color2': msgid_sub2} + ) # A circular reference should not lead to crashes - msgid1 = factory(u"47-not-there", 'Message 1 and $msg2', - mapping={}) - msgid2 = factory(u"48-not-there", 'Message 2 and $msg1', - mapping={}) + msgid1 = factory(u"47-not-there", 'Message 1 and $msg2', mapping={}) + msgid2 = factory(u"48-not-there", 'Message 2 and $msg1', mapping={}) msgid1.mapping['msg2'] = msgid2 msgid2.mapping['msg1'] = msgid1 - self.assertRaises(ValueError, - translate, msgid1, None, None, 'en', "default") + self.assertRaises( + ValueError, translate, msgid1, None, None, 'en', "default" + ) # Recursive translations also work if the original message id wasn't a # message id but a Unicode with a directly passed mapping self.assertEqual( "Color: BLUE/YELLOW", - translate(u"Color: ${color1}/${color2}", mapping=mapping, - target_language='en')) + translate( + u"Color: ${color1}/${color2}", + mapping=mapping, + target_language='en', + ), + ) # If we have mapping with a message id from a different # domain, make sure we use that domain, not ours. If the @@ -127,29 +151,34 @@ class TestGlobalTranslationDomain(TestITranslationDomain, unittest.TestCase): alt_factory = MessageFactory('alt') msgid_sub = alt_factory(u"special", default=u"oohhh") mapping = {'message': msgid_sub} - msgid = factory(u"46-not-there", 'Message: ${message}', - mapping=mapping) + msgid = factory( + u"46-not-there", 'Message: ${message}', mapping=mapping + ) # test we get a default with no domain registered self.assertEqual( translate(msgid, target_language='en', default="default"), - "Message: oohhh") + "Message: oohhh", + ) # provide the domain domain = TranslationDomain('alt') path = testdir - en_catalog = GettextMessageCatalog('en', 'alt', - os.path.join(path, 'en-alt.mo')) + en_catalog = GettextMessageCatalog( + 'en', 'alt', os.path.join(path, 'en-alt.mo') + ) domain.addCatalog(en_catalog) # test that we get the right translation zope.component.provideUtility(domain, ITranslationDomain, 'alt') self.assertEqual( translate(msgid, target_language='en', default="default"), - "Message: Wow") + "Message: Wow", + ) def testMessageIDTranslateForDifferentDomain(self): domain = TranslationDomain('alt') path = testdir - en_catalog = GettextMessageCatalog('en', 'alt', - os.path.join(path, 'en-alt.mo')) + en_catalog = GettextMessageCatalog( + 'en', 'alt', os.path.join(path, 'en-alt.mo') + ) domain.addCatalog(en_catalog) zope.component.provideUtility(domain, ITranslationDomain, 'alt') @@ -157,34 +186,34 @@ class TestGlobalTranslationDomain(TestITranslationDomain, unittest.TestCase): factory = MessageFactory('alt') msgid = factory(u"special", 'default') self.assertEqual( - self._domain.translate(msgid, target_language='en'), u"Wow") + self._domain.translate(msgid, target_language='en'), u"Wow" + ) def testSimpleFallbackTranslation(self): translate = self._domain.translate eq = self.assertEqual # Test that a translation in an unsupported language returns a # translation in the fallback language (by default, English) - eq(translate('short_greeting', target_language='es'), - u"Hello!") + eq(translate('short_greeting', target_language='es'), u"Hello!") # Same test, but use the context argument instead of target_language context = Environment() - eq(translate('short_greeting', context=context), - u"Hello!") + eq(translate('short_greeting', context=context), u"Hello!") def testInterpolationWithoutTranslation(self): translate = self._domain.translate self.assertEqual( - translate('42-not-there', target_language="en", - default="this ${that} the other", - mapping={"that": "THAT"}), - "this THAT the other") + translate( + '42-not-there', + target_language="en", + default="this ${that} the other", + mapping={"that": "THAT"}, + ), + "this THAT the other", + ) def test_getCatalogInfos(self): cats = self._domain.getCatalogsInfo() - self.assertEqual( - cats, - {'en': [en_file], - 'de': [de_file]}) + self.assertEqual(cats, {'en': [en_file], 'de': [de_file]}) def test_releoadCatalogs(self): # It uses the keys we pass diff --git a/src/zope/i18n/tests/test_zcml.py b/src/zope/i18n/tests/test_zcml.py index 52ee437..89bff33 100644 --- a/src/zope/i18n/tests/test_zcml.py +++ b/src/zope/i18n/tests/test_zcml.py @@ -37,6 +37,7 @@ template = """\ %s </configure>""" + class DirectivesTest(PlacelessSetup, unittest.TestCase): # This test suite needs the [zcml] and [compile] extra dependencies @@ -54,13 +55,21 @@ class DirectivesTest(PlacelessSetup, unittest.TestCase): def testRegisterTranslations(self): self.assertTrue(queryUtility(ITranslationDomain) is None) xmlconfig.string( - template % ''' + template + % ''' <configure package="zope.i18n.tests"> <i18n:registerTranslations directory="locale" /> </configure> - ''', self.context) - path = os.path.join(os.path.dirname(zope.i18n.tests.__file__), - 'locale', 'en', 'LC_MESSAGES', 'zope-i18n.mo') + ''', + self.context, + ) + path = os.path.join( + os.path.dirname(zope.i18n.tests.__file__), + 'locale', + 'en', + 'LC_MESSAGES', + 'zope-i18n.mo', + ) util = getUtility(ITranslationDomain, 'zope-i18n') self.assertEqual(util._catalogs.get('test'), ['test']) self.assertEqual(util._catalogs.get('en'), [text_type(path)]) @@ -69,39 +78,65 @@ class DirectivesTest(PlacelessSetup, unittest.TestCase): self.assertTrue(queryUtility(ITranslationDomain) is None) config.ALLOWED_LANGUAGES = ('de', 'fr') xmlconfig.string( - template % ''' + template + % ''' <configure package="zope.i18n.tests"> <i18n:registerTranslations directory="locale" /> </configure> - ''', self.context) - path = os.path.join(os.path.dirname(zope.i18n.tests.__file__), - 'locale', 'de', 'LC_MESSAGES', 'zope-i18n.mo') + ''', + self.context, + ) + path = os.path.join( + os.path.dirname(zope.i18n.tests.__file__), + 'locale', + 'de', + 'LC_MESSAGES', + 'zope-i18n.mo', + ) util = getUtility(ITranslationDomain, 'zope-i18n') - self.assertEqual(util._catalogs, - {'test': ['test'], 'de': [text_type(path)]}) + self.assertEqual( + util._catalogs, {'test': ['test'], 'de': [text_type(path)]} + ) def testRegisterDistributedTranslations(self): self.assertTrue(queryUtility(ITranslationDomain, 'zope-i18n') is None) xmlconfig.string( - template % ''' + template + % ''' <configure package="zope.i18n.tests"> <i18n:registerTranslations directory="locale" /> </configure> - ''', self.context) + ''', + self.context, + ) xmlconfig.string( - template % ''' + template + % ''' <configure package="zope.i18n.tests"> <i18n:registerTranslations directory="locale2" /> </configure> - ''', self.context) - path1 = os.path.join(os.path.dirname(zope.i18n.tests.__file__), - 'locale', 'en', 'LC_MESSAGES', 'zope-i18n.mo') - path2 = os.path.join(os.path.dirname(zope.i18n.tests.__file__), - 'locale2', 'en', 'LC_MESSAGES', 'zope-i18n.mo') + ''', + self.context, + ) + path1 = os.path.join( + os.path.dirname(zope.i18n.tests.__file__), + 'locale', + 'en', + 'LC_MESSAGES', + 'zope-i18n.mo', + ) + path2 = os.path.join( + os.path.dirname(zope.i18n.tests.__file__), + 'locale2', + 'en', + 'LC_MESSAGES', + 'zope-i18n.mo', + ) util = getUtility(ITranslationDomain, 'zope-i18n') self.assertEqual(util._catalogs.get('test'), ['test', 'test']) - self.assertEqual(util._catalogs.get('en'), - [text_type(path1), text_type(path2)]) + self.assertEqual( + util._catalogs.get('en'), [text_type(path1), text_type(path2)] + ) msg = util.translate(u"Additional message", target_language='en') self.assertEqual(msg, u"Additional message translated") @@ -131,14 +166,18 @@ class DirectivesTest(PlacelessSetup, unittest.TestCase): os.utime(path, (path_atime, path_mtime - 6000)) xmlconfig.string( - template % ''' + template + % ''' <configure package="zope.i18n.tests"> <i18n:registerTranslations directory="locale3" /> </configure> - ''', self.context) + ''', + self.context, + ) util = getUtility(ITranslationDomain, 'zope-i18n') - self.assertEqual(util._catalogs, - {'test': ['test'], 'en': [text_type(path)]}) + self.assertEqual( + util._catalogs, {'test': ['test'], 'en': [text_type(path)]} + ) msg = util.translate(u"I'm a newer file", target_language='en') self.assertEqual(msg, u"I'm a newer file translated") @@ -154,22 +193,33 @@ class DirectivesTest(PlacelessSetup, unittest.TestCase): self.assertTrue(queryUtility(ITranslationDomain, 'zope-i18n') is None) self.assertTrue(queryUtility(ITranslationDomain, 'zope-i18n2') is None) xmlconfig.string( - template % ''' + template + % ''' <configure package="zope.i18n.tests"> <i18n:registerTranslations directory="locale3" domain="zope-i18n" /> </configure> - ''', self.context) - path = os.path.join(os.path.dirname(zope.i18n.tests.__file__), - 'locale3', 'en', 'LC_MESSAGES', 'zope-i18n.mo') + ''', + self.context, + ) + path = os.path.join( + os.path.dirname(zope.i18n.tests.__file__), + 'locale3', + 'en', + 'LC_MESSAGES', + 'zope-i18n.mo', + ) util = getUtility(ITranslationDomain, 'zope-i18n') - self.assertEqual(util._catalogs, - {'test': ['test'], 'en': [text_type(path)]}) + self.assertEqual( + util._catalogs, {'test': ['test'], 'en': [text_type(path)]} + ) self.assertTrue(queryUtility(ITranslationDomain, 'zope-i18n2') is None) def test_suite(): - return unittest.TestSuite(( - unittest.defaultTestLoader.loadTestsFromName(__name__), - doctest.DocFileSuite('configure.txt'), - )) + return unittest.TestSuite( + ( + unittest.defaultTestLoader.loadTestsFromName(__name__), + doctest.DocFileSuite('configure.txt'), + ) + ) diff --git a/src/zope/i18n/tests/testi18nawareobject.py b/src/zope/i18n/tests/testi18nawareobject.py index 21a61f4..b1a175e 100644 --- a/src/zope/i18n/tests/testi18nawareobject.py +++ b/src/zope/i18n/tests/testi18nawareobject.py @@ -21,7 +21,6 @@ from zope.interface import implementer @implementer(II18nAware) class I18nAwareContentObject(object): - def __init__(self): self.content = {} self.defaultLanguage = 'en' @@ -54,8 +53,8 @@ class I18nAwareContentObject(object): # ############################################################ -class AbstractTestII18nAwareMixin(object): +class AbstractTestII18nAwareMixin(object): def setUp(self): self.object = self._createObject() self.object.setDefaultLanguage('fr') @@ -73,11 +72,12 @@ class AbstractTestII18nAwareMixin(object): self.assertEqual(self.object.getDefaultLanguage(), 'lt') def testGetAvailableLanguages(self): - self.assertEqual(sorted(self.object.getAvailableLanguages()), ['en', 'fr', 'lt']) + self.assertEqual( + sorted(self.object.getAvailableLanguages()), ['en', 'fr', 'lt'] + ) class TestI18nAwareObject(AbstractTestII18nAwareMixin, unittest.TestCase): - def _createObject(self): object = I18nAwareContentObject() object.setContent('English', 'en') |