============================= test session starts ==============================
platform linux -- Python 3.10.12, pytest-9.0.3, pluggy-1.6.0
rootdir: /workspace/babel
configfile: setup.cfg
plugins: anyio-4.13.0, metadata-3.1.1, json-report-1.5.0, cov-7.1.0
collected 903 items / 3 errors

tests/messages/test_catalog.py .F.....FFFFFFFFFFFFFFFFFFF.FFFFFFFFF.FFF  [  4%]
tests/messages/test_extract.py FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF  [  8%]
tests/messages/test_js_extract.py FFFFFFFFFFFFFF                         [ 10%]
tests/messages/test_jslexer.py FFFFFF                                    [ 11%]
tests/messages/test_mofile.py FF.F                                       [ 11%]
tests/messages/test_normalized_string.py F                               [ 11%]
tests/messages/test_pofile.py FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF [ 16%]
FFFFFFFFFFFF                                                             [ 17%]
tests/messages/test_setuptools_frontend.py FFFF                          [ 18%]
tests/test_core.py ..................................................... [ 23%]
...............................................................          [ 30%]
tests/test_date_intervals.py FF..FF                                      [ 31%]
tests/test_dates.py F...FFF.......F.F.FFF............................... [ 37%]
..........................F                                              [ 40%]
tests/test_support.py FF                                                 [ 40%]
tests/test_date_intervals.py F                                           [ 40%]
tests/test_dates.py F...FFF........FFF.................................. [ 46%]
.......................F                                                 [ 49%]
tests/test_support.py FF                                                 [ 49%]
tests/test_date_intervals.py F..                                         [ 49%]
tests/test_dates.py ....F....F...................F..F....                [ 53%]
tests/test_day_periods.py ..........                                     [ 54%]
tests/test_languages.py ..                                               [ 55%]
tests/test_lists.py ..                                                   [ 55%]
tests/test_localedata.py ............s                                   [ 56%]
tests/test_numbers.py .................................................. [ 62%]
........................................................................ [ 70%]
..........                                                               [ 71%]
tests/test_plural.py .............................................       [ 76%]
tests/test_smoke.py .................................................... [ 82%]
..............................................................FFFFFFFFFF [ 90%]
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF                          [ 95%]
tests/test_support.py ....sss.s........F.F.FFFFFFFFF                     [ 98%]
tests/test_util.py .............                                         [100%]

==================================== ERRORS ====================================
_______________ ERROR collecting tests/messages/test_checkers.py _______________
ImportError while importing test module '/workspace/babel/tests/messages/test_checkers.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
/usr/lib/python3.10/importlib/__init__.py:126: in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
tests/messages/test_checkers.py:20: in <module>
    from babel.messages import checkers
babel/messages/checkers.py:14: in <module>
    from babel.messages.catalog import PYTHON_FORMAT, Catalog, Message, TranslationError
E   ImportError: cannot import name 'PYTHON_FORMAT' from 'babel.messages.catalog' (/workspace/babel/babel/messages/catalog.py)
_______________ ERROR collecting tests/messages/test_frontend.py _______________
ImportError while importing test module '/workspace/babel/tests/messages/test_frontend.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
/usr/lib/python3.10/importlib/__init__.py:126: in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
tests/messages/test_frontend.py:28: in <module>
    from babel.messages import Catalog, extract, frontend
babel/messages/frontend.py:27: in <module>
    from babel.messages.catalog import DEFAULT_HEADER, Catalog
E   ImportError: cannot import name 'DEFAULT_HEADER' from 'babel.messages.catalog' (/workspace/babel/babel/messages/catalog.py)
_______________ ERROR collecting tests/messages/test_plurals.py ________________
tests/messages/test_plurals.py:22: in <module>
    (Locale('zh', script='Hans'), 1, '0'),
babel/core.py:37: in __init__
    raise UnknownLocaleError(str(self))
E   babel.core.UnknownLocaleError: unknown locale 'zh_Hans'
=================================== FAILURES ===================================
______________________ MessageTestCase.test_python_format ______________________

self = <tests.messages.test_catalog.MessageTestCase testMethod=test_python_format>

    def test_python_format(self):
>       assert catalog.PYTHON_FORMAT.search('foo %d bar')
E       AttributeError: module 'babel.messages.catalog' has no attribute 'PYTHON_FORMAT'

tests/messages/test_catalog.py:26: AttributeError
____________ CatalogTestCase.test_fuzzy_matching_regarding_plurals _____________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_fuzzy_matching_regarding_plurals>

    def test_fuzzy_matching_regarding_plurals(self):
        cat = catalog.Catalog()
        cat.add(('foo', 'foh'), ('foo', 'foh'))
        ru = copy.copy(cat)
        ru.locale = 'ru_RU'
        ru.update(cat)
>       assert ru['foo'].fuzzy is True

tests/messages/test_catalog.py:246: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <babel.messages.catalog.Catalog object at 0x77b0dfdd28c0>, id = 'foo'

>   def __getitem__(self, id): return self._messages[self._key_for(id)]
E   KeyError: (None, 'foo')

babel/messages/catalog.py:19: KeyError
___ CatalogTestCase.test_mime_headers_contain_same_information_as_attributes ___

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_mime_headers_contain_same_information_as_attributes>

    def test_mime_headers_contain_same_information_as_attributes(self):
        cat = catalog.Catalog()
>       cat[''] = catalog.Message('',
                                  "Last-Translator: Foo Bar <foo.bar@example.com>\n" +
                                  "Language-Team: de <de@example.com>\n" +
                                  "POT-Creation-Date: 2009-03-01 11:20+0200\n" +
                                  "PO-Revision-Date: 2009-03-09 15:47-0700\n")
E       TypeError: 'Catalog' object does not support item assignment

tests/messages/test_catalog.py:312: TypeError
________________ CatalogTestCase.test_stores_datetime_correctly ________________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_stores_datetime_correctly>

    def test_stores_datetime_correctly(self):
        localized = catalog.Catalog()
        localized.locale = 'de_DE'
>       localized[''] = catalog.Message('',
                                        "POT-Creation-Date: 2009-03-09 15:47-0700\n" +
                                        "PO-Revision-Date: 2009-03-09 15:47-0700\n")
E       TypeError: 'Catalog' object does not support item assignment

tests/messages/test_catalog.py:303: TypeError
_____________ CatalogTestCase.test_two_messages_with_same_singular _____________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_two_messages_with_same_singular>

    def test_two_messages_with_same_singular(self):
        cat = catalog.Catalog()
        cat.add('foo')
        cat.add(('foo', 'foos'))
>       assert len(cat) == 1
E       assert 2 == 1
E        +  where 2 = len(<babel.messages.catalog.Catalog object at 0x77b0dfcdffd0>)

tests/messages/test_catalog.py:70: AssertionError
____________ CatalogTestCase.test_update_fuzzy_matching_long_string ____________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_fuzzy_matching_long_string>

        def test_update_fuzzy_matching_long_string(self):
            lipsum = "\
    Lorem Ipsum is simply dummy text of the printing and typesetting \
    industry. Lorem Ipsum has been the industry's standard dummy text ever \
    since the 1500s, when an unknown printer took a galley of type and \
    scrambled it to make a type specimen book. It has survived not only \
    five centuries, but also the leap into electronic typesetting, \
    remaining essentially unchanged. It was popularised in the 1960s with \
    the release of Letraset sheets containing Lorem Ipsum passages, and \
    more recently with desktop publishing software like Aldus PageMaker \
    including versions of Lorem Ipsum."
            cat = catalog.Catalog()
            cat.add("ZZZZZZ " + lipsum, "foo")
            tmpl = catalog.Catalog()
            tmpl.add(lipsum + " ZZZZZZ")
            cat.update(tmpl)
>           assert cat[lipsum + " ZZZZZZ"].fuzzy is True
E           assert False is True
E            +  where False = <Message "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry...es, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum. ZZZZZZ">.fuzzy

tests/messages/test_catalog.py:228: AssertionError
___________ CatalogTestCase.test_update_fuzzy_matching_no_cascading ____________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_fuzzy_matching_no_cascading>

    def test_update_fuzzy_matching_no_cascading(self):
        cat = catalog.Catalog()
        cat.add('fo', 'Voh')
        cat.add('foo', 'Vohe')
        tmpl = catalog.Catalog()
        tmpl.add('fo')
        tmpl.add('foo')
        tmpl.add('fooo')
        cat.update(tmpl)
        assert 'fo' in cat
        assert 'foo' in cat
    
>       assert cat['fo'].string == 'Voh'
E       AssertionError: assert '' == 'Voh'
E         
E         - Voh

tests/messages/test_catalog.py:205: AssertionError
_____________ CatalogTestCase.test_update_fuzzy_matching_no_msgstr _____________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_fuzzy_matching_no_msgstr>

    def test_update_fuzzy_matching_no_msgstr(self):
        cat = catalog.Catalog()
        cat.add('fo', '')
        tmpl = catalog.Catalog()
        tmpl.add('fo')
        tmpl.add('foo')
        cat.update(tmpl)
        assert 'fo' in cat
        assert 'foo' in cat
    
        assert cat['fo'].string == ''
        assert cat['fo'].fuzzy is False
>       assert cat['foo'].string is None
E       AssertionError: assert '' is None
E        +  where '' = <Message 'foo'>.string

tests/messages/test_catalog.py:160: AssertionError
_________ CatalogTestCase.test_update_fuzzy_matching_with_case_change __________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_fuzzy_matching_with_case_change>

    def test_update_fuzzy_matching_with_case_change(self):
        cat = catalog.Catalog()
        cat.add('FOO', 'Voh')
        cat.add('bar', 'Bahr')
        tmpl = catalog.Catalog()
        tmpl.add('foo')
        cat.update(tmpl)
>       assert len(cat.obsolete) == 1
E       AttributeError: 'Catalog' object has no attribute 'obsolete'

tests/messages/test_catalog.py:129: AttributeError
_______ CatalogTestCase.test_update_fuzzy_matching_with_changed_context ________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_fuzzy_matching_with_changed_context>

    def test_update_fuzzy_matching_with_changed_context(self):
        cat = catalog.Catalog()
        cat.add('foo', 'Voh', context='Menu|File')
        cat.add('bar', 'Bahr', context='Menu|File')
        tmpl = catalog.Catalog()
        tmpl.add('Foo', context='Menu|Edit')
        cat.update(tmpl)
>       assert len(cat.obsolete) == 1
E       AttributeError: 'Catalog' object has no attribute 'obsolete'

tests/messages/test_catalog.py:185: AttributeError
_________ CatalogTestCase.test_update_fuzzy_matching_with_char_change __________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_fuzzy_matching_with_char_change>

    def test_update_fuzzy_matching_with_char_change(self):
        cat = catalog.Catalog()
        cat.add('fo', 'Voh')
        cat.add('bar', 'Bahr')
        tmpl = catalog.Catalog()
        tmpl.add('foo')
        cat.update(tmpl)
>       assert len(cat.obsolete) == 1
E       AttributeError: 'Catalog' object has no attribute 'obsolete'

tests/messages/test_catalog.py:142: AttributeError
_________ CatalogTestCase.test_update_fuzzy_matching_with_new_context __________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_fuzzy_matching_with_new_context>

    def test_update_fuzzy_matching_with_new_context(self):
        cat = catalog.Catalog()
        cat.add('foo', 'Voh')
        cat.add('bar', 'Bahr')
        tmpl = catalog.Catalog()
        tmpl.add('Foo', context='Menu')
        cat.update(tmpl)
>       assert len(cat.obsolete) == 1
E       AttributeError: 'Catalog' object has no attribute 'obsolete'

tests/messages/test_catalog.py:170: AttributeError
____________ CatalogTestCase.test_update_message_changed_to_plural _____________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_message_changed_to_plural>

    def test_update_message_changed_to_plural(self):
        cat = catalog.Catalog()
        cat.add('foo', 'Voh')
        tmpl = catalog.Catalog()
        tmpl.add(('foo', 'foos'))
        cat.update(tmpl)
>       assert cat['foo'].string == ('Voh', '')
E       AssertionError: assert 'Voh' == ('Voh', '')
E        +  where 'Voh' = <Message 'foo'>.string

tests/messages/test_catalog.py:96: AssertionError
____________ CatalogTestCase.test_update_message_changed_to_simple _____________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_message_changed_to_simple>

    def test_update_message_changed_to_simple(self):
        cat = catalog.Catalog()
        cat.add('foo' 'foos', ('Voh', 'Vöhs'))
        tmpl = catalog.Catalog()
        tmpl.add('foo')
        cat.update(tmpl)
>       assert cat['foo'].string == 'Voh'
E       AssertionError: assert '' == 'Voh'
E         
E         - Voh

tests/messages/test_catalog.py:105: AssertionError
_____________ CatalogTestCase.test_update_message_updates_comments _____________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_message_updates_comments>

    def test_update_message_updates_comments(self):
        cat = catalog.Catalog()
>       cat['foo'] = catalog.Message('foo', locations=[('main.py', 5)])
E       TypeError: 'Catalog' object does not support item assignment

tests/messages/test_catalog.py:110: TypeError
_______________ CatalogTestCase.test_update_no_template_mutation _______________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_no_template_mutation>

    def test_update_no_template_mutation(self):
        tmpl = catalog.Catalog()
        tmpl.add('foo')
        cat1 = catalog.Catalog()
        cat1.add('foo', 'Voh')
        cat1.update(tmpl)
        cat2 = catalog.Catalog()
        cat2.update(tmpl)
    
>       assert cat2['foo'].string is None
E       AssertionError: assert '' is None
E        +  where '' = <Message 'foo'>.string

tests/messages/test_catalog.py:262: AssertionError
___________ CatalogTestCase.test_update_po_ignores_pot_creation_date ___________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_po_ignores_pot_creation_date>

    def test_update_po_ignores_pot_creation_date(self):
        template = catalog.Catalog()
        localized_catalog = copy.deepcopy(template)
        localized_catalog.locale = 'de_DE'
>       assert template.mime_headers != localized_catalog.mime_headers
E       assert [] != []
E        +  where [] = <babel.messages.catalog.Catalog object at 0x77b0e071d600>.mime_headers
E        +  and   [] = <babel.messages.catalog.Catalog object at 0x77b0e071e740>.mime_headers

tests/messages/test_catalog.py:280: AssertionError
____________ CatalogTestCase.test_update_po_keeps_po_revision_date _____________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_po_keeps_po_revision_date>

    def test_update_po_keeps_po_revision_date(self):
        template = catalog.Catalog()
        localized_catalog = copy.deepcopy(template)
        localized_catalog.locale = 'de_DE'
        fake_rev_date = datetime.datetime.now() - datetime.timedelta(days=5)
        localized_catalog.revision_date = fake_rev_date
>       assert template.mime_headers != localized_catalog.mime_headers
E       assert [] != []
E        +  where [] = <babel.messages.catalog.Catalog object at 0x77b0dfcde2f0>.mime_headers
E        +  and   [] = <babel.messages.catalog.Catalog object at 0x77b0dfcdf8b0>.mime_headers

tests/messages/test_catalog.py:293: AssertionError
___________ CatalogTestCase.test_update_po_updates_pot_creation_date ___________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_po_updates_pot_creation_date>

    def test_update_po_updates_pot_creation_date(self):
        template = catalog.Catalog()
        localized_catalog = copy.deepcopy(template)
        localized_catalog.locale = 'de_DE'
>       assert template.mime_headers != localized_catalog.mime_headers
E       assert [] != []
E        +  where [] = <babel.messages.catalog.Catalog object at 0x77b0e06e1090>.mime_headers
E        +  and   [] = <babel.messages.catalog.Catalog object at 0x77b0e06e2350>.mime_headers

tests/messages/test_catalog.py:269: AssertionError
______________ CatalogTestCase.test_update_without_fuzzy_matching ______________

self = <tests.messages.test_catalog.CatalogTestCase testMethod=test_update_without_fuzzy_matching>

    def test_update_without_fuzzy_matching(self):
        cat = catalog.Catalog()
        cat.add('fo', 'Voh')
        cat.add('bar', 'Bahr')
        tmpl = catalog.Catalog()
        tmpl.add('foo')
        cat.update(tmpl, no_fuzzy_matching=True)
>       assert len(cat.obsolete) == 2
E       AttributeError: 'Catalog' object has no attribute 'obsolete'

tests/messages/test_catalog.py:238: AttributeError
__________________________ test_message_pluralizable ___________________________

    def test_message_pluralizable():
>       assert not catalog.Message('foo').pluralizable
E       AttributeError: 'Message' object has no attribute 'pluralizable'

tests/messages/test_catalog.py:340: AttributeError
__________________________ test_message_python_format __________________________

    def test_message_python_format():
>       assert catalog.Message('foo %(name)s bar').python_format
E       AttributeError: 'Message' object has no attribute 'python_format'

tests/messages/test_catalog.py:345: AttributeError
_________________________________ test_catalog _________________________________

    def test_catalog():
        cat = catalog.Catalog(project='Foobar', version='1.0',
                              copyright_holder='Foo Company')
>       assert cat.header_comment == (
            '# Translations template for Foobar.\n'
            '# Copyright (C) %(year)d Foo Company\n'
            '# This file is distributed under the same '
            'license as the Foobar project.\n'
            '# FIRST AUTHOR <EMAIL@ADDRESS>, %(year)d.\n'
            '#') % {'year': datetime.date.today().year}
E       AssertionError: assert '' == '# Translatio...SS>, 2026.\n#'
E         
E         - # Translations template for Foobar.
E         - # Copyright (C) 2026 Foo Company
E         - # This file is distributed under the same license as the Foobar project.
E         - # FIRST AUTHOR <EMAIL@ADDRESS>, 2026.
E         - #

tests/messages/test_catalog.py:352: AssertionError
__________________________ test_catalog_mime_headers ___________________________

    def test_catalog_mime_headers():
        created = datetime.datetime(1990, 4, 1, 15, 30, tzinfo=UTC)
        cat = catalog.Catalog(project='Foobar', version='1.0',
                              creation_date=created)
        assert cat.mime_headers == [
            ('Project-Id-Version', 'Foobar 1.0'),
            ('Report-Msgid-Bugs-To', 'EMAIL@ADDRESS'),
            ('POT-Creation-Date', '1990-04-01 15:30+0000'),
            ('PO-Revision-Date', 'YEAR-MO-DA HO:MI+ZONE'),
            ('Last-Translator', 'FULL NAME <EMAIL@ADDRESS>'),
            ('Language-Team', 'LANGUAGE <LL@li.org>'),
            ('MIME-Version', '1.0'),
            ('Content-Type', 'text/plain; charset=utf-8'),
            ('Content-Transfer-Encoding', '8bit'),
>           ('Generated-By', f'Babel {catalog.VERSION}\n'),
        ]
E       AttributeError: module 'babel.messages.catalog' has no attribute 'VERSION'

tests/messages/test_catalog.py:390: AttributeError
_____________________ test_catalog_mime_headers_set_locale _____________________

    def test_catalog_mime_headers_set_locale():
        created = datetime.datetime(1990, 4, 1, 15, 30, tzinfo=UTC)
        revised = datetime.datetime(1990, 8, 3, 12, 0, tzinfo=UTC)
        cat = catalog.Catalog(locale='de_DE', project='Foobar', version='1.0',
                              creation_date=created, revision_date=revised,
                              last_translator='John Doe <jd@example.com>',
                              language_team='de_DE <de@example.com>')
        assert cat.mime_headers == [
            ('Project-Id-Version', 'Foobar 1.0'),
            ('Report-Msgid-Bugs-To', 'EMAIL@ADDRESS'),
            ('POT-Creation-Date', '1990-04-01 15:30+0000'),
            ('PO-Revision-Date', '1990-08-03 12:00+0000'),
            ('Last-Translator', 'John Doe <jd@example.com>'),
            ('Language', 'de_DE'),
            ('Language-Team', 'de_DE <de@example.com>'),
            ('Plural-Forms', 'nplurals=2; plural=(n != 1);'),
            ('MIME-Version', '1.0'),
            ('Content-Type', 'text/plain; charset=utf-8'),
            ('Content-Transfer-Encoding', '8bit'),
>           ('Generated-By', f'Babel {catalog.VERSION}\n'),
        ]
E       AttributeError: module 'babel.messages.catalog' has no attribute 'VERSION'

tests/messages/test_catalog.py:413: AttributeError
___________________________ test_catalog_num_plurals ___________________________

    def test_catalog_num_plurals():
        assert catalog.Catalog(locale='en').num_plurals == 2
>       assert catalog.Catalog(locale='ga').num_plurals == 5
E       AssertionError: assert 2 == 5
E        +  where 2 = <babel.messages.catalog.Catalog object at 0x77b0e071c0a0>.num_plurals
E        +    where <babel.messages.catalog.Catalog object at 0x77b0e071c0a0> = <class 'babel.messages.catalog.Catalog'>(locale='ga')
E        +      where <class 'babel.messages.catalog.Catalog'> = catalog.Catalog

tests/messages/test_catalog.py:419: AssertionError
___________________________ test_catalog_plural_expr ___________________________

    def test_catalog_plural_expr():
        assert catalog.Catalog(locale='en').plural_expr == '(n != 1)'
>       assert (catalog.Catalog(locale='ga').plural_expr
                == '(n==1 ? 0 : n==2 ? 1 : n>=3 && n<=6 ? 2 : n>=7 && n<=10 ? 3 : 4)')
E       AssertionError: assert '(n != 1)' == '(n==1 ? 0 : ...<=10 ? 3 : 4)'
E         
E         - (n==1 ? 0 : n==2 ? 1 : n>=3 && n<=6 ? 2 : n>=7 && n<=10 ? 3 : 4)
E         + (n != 1)

tests/messages/test_catalog.py:424: AssertionError
__________________________ test_catalog_plural_forms ___________________________

    def test_catalog_plural_forms():
>       assert (catalog.Catalog(locale='en').plural_forms
                == 'nplurals=2; plural=(n != 1);')
E       AttributeError: 'Catalog' object has no attribute 'plural_forms'

tests/messages/test_catalog.py:429: AttributeError
_____________________________ test_catalog_setitem _____________________________

    def test_catalog_setitem():
        cat = catalog.Catalog()
>       cat['foo'] = catalog.Message('foo')
E       TypeError: 'Catalog' object does not support item assignment

tests/messages/test_catalog.py:437: TypeError
_____________________________ test_catalog_update ______________________________

    def test_catalog_update():
        template = catalog.Catalog(header_comment="# A Custom Header")
        template.add('green', locations=[('main.py', 99)])
        template.add('blue', locations=[('main.py', 100)])
        template.add(('salad', 'salads'), locations=[('util.py', 42)])
        cat = catalog.Catalog(locale='de_DE')
        cat.add('blue', 'blau', locations=[('main.py', 98)])
        cat.add('head', 'Kopf', locations=[('util.py', 33)])
        cat.add(('salad', 'salads'), ('Salat', 'Salate'),
                locations=[('util.py', 38)])
    
        cat.update(template)
>       assert len(cat) == 3
E       assert 4 == 3
E        +  where 4 = len(<babel.messages.catalog.Catalog object at 0x77b0dfc37010>)

tests/messages/test_catalog.py:466: AssertionError
____________________________ test_datetime_parsing _____________________________

    def test_datetime_parsing():
>       val1 = catalog._parse_datetime_header('2006-06-28 23:24+0200')
E       AttributeError: module 'babel.messages.catalog' has no attribute '_parse_datetime_header'

tests/messages/test_catalog.py:488: AttributeError
_________________________ test_update_catalog_comments _________________________

    def test_update_catalog_comments():
        # Based on https://web.archive.org/web/20100710131029/http://babel.edgewall.org/attachment/ticket/163/cat-update-comments.py
    
        catalog = pofile.read_po(StringIO('''
        # A user comment
        #. An auto comment
        #: main.py:1
        #, fuzzy, python-format
        msgid "foo %(name)s"
        msgstr "foo %(name)s"
        '''))
    
>       assert all(message.user_comments and message.auto_comments for message in catalog if message.id)
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_catalog.py:513: TypeError
____________________ ExtractPythonTestCase.test_comment_tag ____________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_comment_tag>

        def test_comment_tag(self):
            buf = BytesIO(b"""
    # NOTE: A translation comment
    msg = _(u'Foo Bar')
    """)
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:213: TypeError
_______________ ExtractPythonTestCase.test_comment_tag_multiline _______________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_comment_tag_multiline>

        def test_comment_tag_multiline(self):
            buf = BytesIO(b"""
    # NOTE: A translation comment
    # with a second line
    msg = _(u'Foo Bar')
    """)
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:223: TypeError
__________ ExtractPythonTestCase.test_comment_tag_with_leading_space ___________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_comment_tag_with_leading_space>

        def test_comment_tag_with_leading_space(self):
            buf = BytesIO(b"""
      #: A translation comment
      #: with leading spaces
    msg = _(u'Foo Bar')
    """)
>           messages = list(extract.extract_python(buf, ('_',), [':'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:322: TypeError
_______ ExtractPythonTestCase.test_comment_tags_not_on_start_of_comment ________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_comment_tags_not_on_start_of_comment>

        def test_comment_tags_not_on_start_of_comment(self):
            buf = BytesIO(b"""
    # This shouldn't be in the output
    # because it didn't start with a comment tag
    # do NOTE: this will not be a translation comment
    # NOTE: This one will be
    msg = _(u'Foo Bar')
    """)
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:247: TypeError
___ ExtractPythonTestCase.test_comments_with_calls_that_spawn_multiple_lines ___

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_comments_with_calls_that_spawn_multiple_lines>

        def test_comments_with_calls_that_spawn_multiple_lines(self):
            buf = BytesIO(b"""\
    # NOTE: This Comment SHOULD Be Extracted
    add_notice(req, ngettext("Catalog deleted.",
                             "Catalogs deleted.", len(selected)))
    
    # NOTE: This Comment SHOULD Be Extracted
    add_notice(req, _("Locale deleted."))
    
    
    # NOTE: This Comment SHOULD Be Extracted
    add_notice(req, ngettext("Foo deleted.", "Foos deleted.", len(selected)))
    
    # NOTE: This Comment SHOULD Be Extracted
    # NOTE: And This One Too
    add_notice(req, ngettext("Bar deleted.",
                             "Bars deleted.", len(selected)))
    """)
>           messages = list(extract.extract_python(buf, ('ngettext', '_'), ['NOTE:'],
    
                                                   {'strip_comment_tags': False}))
E                                                  TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:97: TypeError
_______________ ExtractPythonTestCase.test_concatenated_strings ________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_concatenated_strings>

        def test_concatenated_strings(self):
            buf = BytesIO(b"""\
    foobar = _('foo' 'bar')
    """)
>           messages = list(extract.extract_python(buf,
                                                   extract.DEFAULT_KEYWORDS.keys(),
                                                   [], {}))
E                                                  TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:198: TypeError
___________________ ExtractPythonTestCase.test_declarations ____________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_declarations>

        def test_declarations(self):
            buf = BytesIO(b"""\
    class gettext(object):
        pass
    def render_body(context,x,y=_('Page arg 1'),z=_('Page arg 2'),**pageargs):
        pass
    def ngettext(y='arg 1',z='arg 2',**pageargs):
        pass
    class Meta:
        verbose_name = _('log entry')
    """)
>           messages = list(extract.extract_python(buf,
                                                   extract.DEFAULT_KEYWORDS.keys(),
                                                   [], {}))
E                                                  TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:116: TypeError
_______________ ExtractPythonTestCase.test_different_signatures ________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_different_signatures>

        def test_different_signatures(self):
            buf = BytesIO(b"""
    foo = _('foo', 'bar')
    n = ngettext('hello', 'there', n=3)
    n = ngettext(n=3, 'hello', 'there')
    n = ngettext(n=3, *messages)
    n = ngettext()
    n = ngettext('foo')
    """)
>           messages = list(extract.extract_python(buf, ('_', 'ngettext'), [], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:335: TypeError
__________ ExtractPythonTestCase.test_extract_default_encoding_ascii ___________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_extract_default_encoding_ascii>

    def test_extract_default_encoding_ascii(self):
        buf = BytesIO(b'_("a")')
>       messages = list(extract.extract_python(
            buf, list(extract.DEFAULT_KEYWORDS), [], {},
        ))
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:56: TypeError
___________ ExtractPythonTestCase.test_extract_default_encoding_utf8 ___________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_extract_default_encoding_utf8>

    def test_extract_default_encoding_utf8(self):
        buf = BytesIO('_("☃")'.encode('UTF-8'))
>       messages = list(extract.extract_python(
            buf, list(extract.DEFAULT_KEYWORDS), [], {},
        ))
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:64: TypeError
____________ ExtractPythonTestCase.test_extract_strip_comment_tags _____________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_extract_strip_comment_tags>

        def test_extract_strip_comment_tags(self):
            buf = BytesIO(b"""\
    #: This is a comment with a very simple
    #: prefix specified
    _('Servus')
    
    # NOTE: This is a multiline comment with
    # a prefix too
    _('Babatschi')""")
>           messages = list(extract.extract('python', buf, comment_tags=['NOTE:', ':'],
                                            strip_comment_tags=True))
E                                           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:406: TypeError
____________ ExtractPythonTestCase.test_invalid_translator_comments ____________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_invalid_translator_comments>

        def test_invalid_translator_comments(self):
            buf = BytesIO(b"""
    # NOTE: this shouldn't apply to any messages
    hello = 'there'
    
    msg = _(u'Foo Bar')
    """)
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:284: TypeError
___________ ExtractPythonTestCase.test_invalid_translator_comments2 ____________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_invalid_translator_comments2>

        def test_invalid_translator_comments2(self):
            buf = BytesIO(b"""
    # NOTE: Hi!
    hithere = _('Hi there!')
    
    # NOTE: you should not be seeing this in the .po
    rows = [[v for v in range(0,10)] for row in range(0,10)]
    
    # this (NOTE:) should not show up either
    hello = _('Hello')
    """)
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:299: TypeError
___________ ExtractPythonTestCase.test_invalid_translator_comments3 ____________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_invalid_translator_comments3>

        def test_invalid_translator_comments3(self):
            buf = BytesIO(b"""
    # NOTE: Hi,
    
    # there!
    hithere = _('Hi there!')
    """)
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:312: TypeError
_____________________ ExtractPythonTestCase.test_multiline _____________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_multiline>

        def test_multiline(self):
            buf = BytesIO(b"""\
    msg1 = ngettext('pylon',
                    'pylons', count)
    msg2 = ngettext('elvis',
                    'elvises',
                     count)
    """)
>           messages = list(extract.extract_python(buf, ('ngettext',), [], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:133: TypeError
_________________ ExtractPythonTestCase.test_multiline_strings _________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_multiline_strings>

        def test_multiline_strings(self):
            buf = BytesIO(b"""\
    _('''This module provides internationalization and localization
    support for your Python programs by providing an interface to the GNU
    gettext message catalog library.''')
    """)
>           messages = list(extract.extract_python(buf,
                                                   extract.DEFAULT_KEYWORDS.keys(),
                                                   [], {}))
E                                                  TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:184: TypeError
_______________ ExtractPythonTestCase.test_multiple_comment_tags _______________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_multiple_comment_tags>

        def test_multiple_comment_tags(self):
            buf = BytesIO(b"""
    # NOTE1: A translation comment for tag1
    # with a second line
    msg = _(u'Foo Bar1')
    
    # NOTE2: A translation comment for tag2
    msg = _(u'Foo Bar2')
    """)
>           messages = list(extract.extract_python(buf, ('_',),
                                                   ['NOTE1:', 'NOTE2:'], {}))
E                                                  TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:260: TypeError
___________________ ExtractPythonTestCase.test_nested_calls ____________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_nested_calls>

        def test_nested_calls(self):
            buf = BytesIO(b"""\
    msg1 = _(i18n_arg.replace(r'\"', '"'))
    msg2 = ungettext(i18n_arg.replace(r'\"', '"'), multi_arg.replace(r'\"', '"'), 2)
    msg3 = ungettext("Babel", multi_arg.replace(r'\"', '"'), 2)
    msg4 = ungettext(i18n_arg.replace(r'\"', '"'), "Babels", 2)
    msg5 = ungettext('bunny', 'bunnies', random.randint(1, 2))
    msg6 = ungettext(arg0, 'bunnies', random.randint(1, 2))
    msg7 = _(hello.there)
    msg8 = gettext('Rabbit')
    msg9 = dgettext('wiki', model.addPage())
    msg10 = dngettext(getDomain(), 'Page', 'Pages', 3)
    """)
>           messages = list(extract.extract_python(buf,
                                                   extract.DEFAULT_KEYWORDS.keys(),
                                                   [], {}))
E                                                  TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:38: TypeError
__________________ ExtractPythonTestCase.test_nested_comments __________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_nested_comments>

        def test_nested_comments(self):
            buf = BytesIO(b"""\
    msg = ngettext('pylon',  # TRANSLATORS: shouldn't be
                   'pylons', # TRANSLATORS: seeing this
                   count)
    """)
>           messages = list(extract.extract_python(buf, ('ngettext',),
                                                   ['TRANSLATORS:'], {}))
E                                                  TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:75: TypeError
__________________ ExtractPythonTestCase.test_nested_messages __________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_nested_messages>

        def test_nested_messages(self):
            buf = BytesIO(b"""
    # NOTE: First
    _(u'Hello, {name}!', name=_(u'Foo Bar'))
    
    # NOTE: Second
    _(u'Hello, {name1} and {name2}!', name1=_(u'Heungsub'),
      name2=_(u'Armin'))
    
    # NOTE: Third
    _(u'Hello, {0} and {1}!', _(u'Heungsub'),
      _(u'Armin'))
    """)
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:426: TypeError
_____________________ ExtractPythonTestCase.test_npgettext _____________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_npgettext>

        def test_npgettext(self):
            buf = BytesIO(b"""\
    msg1 = npgettext('Strings','pylon',
                    'pylons', count)
    msg2 = npgettext('Strings','elvis',
                    'elvises',
                     count)
    """)
>           messages = list(extract.extract_python(buf, ('npgettext',), [], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:147: TypeError
_ ExtractPythonTestCase.test_translator_comments_with_previous_non_translator_comments _

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_translator_comments_with_previous_non_translator_comments>

        def test_translator_comments_with_previous_non_translator_comments(self):
            buf = BytesIO(b"""
    # This shouldn't be in the output
    # because it didn't start with a comment tag
    # NOTE: A translation comment
    # with a second line
    msg = _(u'Foo Bar')
    """)
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:235: TypeError
_______________ ExtractPythonTestCase.test_triple_quoted_strings _______________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_triple_quoted_strings>

        def test_triple_quoted_strings(self):
            buf = BytesIO(b"""\
    msg1 = _('''pylons''')
    msg2 = ngettext(r'''elvis''', \"\"\"elvises\"\"\", count)
    msg2 = ngettext(\"\"\"elvis\"\"\", 'elvises', count)
    """)
>           messages = list(extract.extract_python(buf,
                                                   extract.DEFAULT_KEYWORDS.keys(),
                                                   [], {}))
E                                                  TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:169: TypeError
______________ ExtractPythonTestCase.test_two_succeeding_comments ______________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_two_succeeding_comments>

        def test_two_succeeding_comments(self):
            buf = BytesIO(b"""
    # NOTE: one
    # NOTE: two
    msg = _(u'Foo Bar')
    """)
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:273: TypeError
________________ ExtractPythonTestCase.test_unicode_string_arg _________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_unicode_string_arg>

    def test_unicode_string_arg(self):
        buf = BytesIO(b"msg = _(u'Foo Bar')")
>       messages = list(extract.extract_python(buf, ('_',), [], {}))
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:205: TypeError
______ ExtractPythonTestCase.test_utf8_bom_with_latin_magic_comment_fails ______

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_utf8_bom_with_latin_magic_comment_fails>

        def test_utf8_bom_with_latin_magic_comment_fails(self):
            buf = BytesIO(codecs.BOM_UTF8 + """# -*- coding: latin-1 -*-
    # NOTE: hello
    msg = _('Bonjour à tous')
    """.encode('utf-8'))
            with pytest.raises(SyntaxError):
>               list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E               TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:386: TypeError
___________________ ExtractPythonTestCase.test_utf8_message ____________________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_utf8_message>

        def test_utf8_message(self):
            buf = BytesIO("""
    # NOTE: hello
    msg = _('Bonjour à tous')
    """.encode('utf-8'))
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'],
                                                   {'encoding': 'utf-8'}))
E                                                  TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:348: TypeError
__________ ExtractPythonTestCase.test_utf8_message_with_magic_comment __________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_utf8_message_with_magic_comment>

        def test_utf8_message_with_magic_comment(self):
            buf = BytesIO("""# -*- coding: utf-8 -*-
    # NOTE: hello
    msg = _('Bonjour à tous')
    """.encode('utf-8'))
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:358: TypeError
____________ ExtractPythonTestCase.test_utf8_message_with_utf8_bom _____________

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_utf8_message_with_utf8_bom>

        def test_utf8_message_with_utf8_bom(self):
            buf = BytesIO(codecs.BOM_UTF8 + """
    # NOTE: hello
    msg = _('Bonjour à tous')
    """.encode('utf-8'))
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:367: TypeError
___ ExtractPythonTestCase.test_utf8_message_with_utf8_bom_and_magic_comment ____

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_utf8_message_with_utf8_bom_and_magic_comment>

        def test_utf8_message_with_utf8_bom_and_magic_comment(self):
            buf = BytesIO(codecs.BOM_UTF8 + """# -*- coding: utf-8 -*-
    # NOTE: hello
    msg = _('Bonjour à tous')
    """.encode('utf-8'))
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:376: TypeError
______ ExtractPythonTestCase.test_utf8_raw_strings_match_unicode_strings _______

self = <tests.messages.test_extract.ExtractPythonTestCase testMethod=test_utf8_raw_strings_match_unicode_strings>

        def test_utf8_raw_strings_match_unicode_strings(self):
            buf = BytesIO(codecs.BOM_UTF8 + """
    msg = _('Bonjour à tous')
    msgu = _(u'Bonjour à tous')
    """.encode('utf-8'))
>           messages = list(extract.extract_python(buf, ('_',), ['NOTE:'], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:393: TypeError
__________________ ExtractTestCase.test_different_signatures ___________________

self = <tests.messages.test_extract.ExtractTestCase testMethod=test_different_signatures>

        def test_different_signatures(self):
            buf = BytesIO(b"""
    foo = _('foo', 'bar')
    n = ngettext('hello', 'there', n=3)
    n = ngettext(n=3, 'hello', 'there')
    n = ngettext(n=3, *messages)
    n = ngettext()
    n = ngettext('foo')
    """)
            messages = \
>               list(extract.extract('python', buf, extract.DEFAULT_KEYWORDS, [],
                                     {}))
E                                    TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:484: TypeError
___________________ ExtractTestCase.test_empty_string_msgid ____________________

self = <tests.messages.test_extract.ExtractTestCase testMethod=test_empty_string_msgid>

        def test_empty_string_msgid(self):
            buf = BytesIO(b"""\
    msg = _('')
    """)
            stderr = sys.stderr
            sys.stderr = StringIO()
            try:
                messages = \
>                   list(extract.extract('python', buf, extract.DEFAULT_KEYWORDS,
                                         [], {}))
E                                        TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:498: TypeError
_________________ ExtractTestCase.test_extract_allows_callable _________________

self = <tests.messages.test_extract.ExtractTestCase testMethod=test_extract_allows_callable>

    def test_extract_allows_callable(self):
        def arbitrary_extractor(fileobj, keywords, comment_tags, options):
            return [(1, None, (), ())]
>       for x in extract.extract(arbitrary_extractor, BytesIO(b"")):
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:519: TypeError
________________________ ExtractTestCase.test_f_strings ________________________

self = <tests.messages.test_extract.ExtractTestCase testMethod=test_f_strings>

        def test_f_strings(self):
            buf = BytesIO(br"""
    t1 = _('foobar')
    t2 = _(f'spameggs' f'feast')  # should be extracted; constant parts only
    t2 = _(f'spameggs' 'kerroshampurilainen')  # should be extracted (mixing f with no f)
    t3 = _(f'''whoa! a '''  # should be extracted (continues on following lines)
    f'flying shark'
        '... hello'
    )
    t4 = _(f'spameggs {t1}')  # should not be extracted
    """)
>           messages = list(extract.extract('python', buf, extract.DEFAULT_KEYWORDS, [], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:543: TypeError
___________________ ExtractTestCase.test_f_strings_non_utf8 ____________________

self = <tests.messages.test_extract.ExtractTestCase testMethod=test_f_strings_non_utf8>

        def test_f_strings_non_utf8(self):
            buf = BytesIO(b"""
    # -- coding: latin-1 --
    t2 = _(f'\xe5\xe4\xf6' f'\xc5\xc4\xd6')
    """)
>           messages = list(extract.extract('python', buf, extract.DEFAULT_KEYWORDS, [], {}))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:555: TypeError
_________________________ ExtractTestCase.test_future __________________________

self = <tests.messages.test_extract.ExtractTestCase testMethod=test_future>

        def test_future(self):
            buf = BytesIO(br"""
    # -*- coding: utf-8 -*-
    from __future__ import unicode_literals
    nbsp = _('\xa0')
    """)
>           messages = list(extract.extract('python', buf,
                                            extract.DEFAULT_KEYWORDS, [], {}))
E                                           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:528: TypeError
_________________ ExtractTestCase.test_invalid_extract_method __________________

self = <tests.messages.test_extract.ExtractTestCase testMethod=test_invalid_extract_method>

    def test_invalid_extract_method(self):
        buf = BytesIO(b'')
        with pytest.raises(ValueError):
>           list(extract.extract('spam', buf))
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:472: TypeError
_____________________ ExtractTestCase.test_invalid_filter ______________________

self = <tests.messages.test_extract.ExtractTestCase testMethod=test_invalid_filter>

        def test_invalid_filter(self):
            buf = BytesIO(b"""\
    msg1 = _(i18n_arg.replace(r'\"', '"'))
    msg2 = ungettext(i18n_arg.replace(r'\"', '"'), multi_arg.replace(r'\"', '"'), 2)
    msg3 = ungettext("Babel", multi_arg.replace(r'\"', '"'), 2)
    msg4 = ungettext(i18n_arg.replace(r'\"', '"'), "Babels", 2)
    msg5 = ungettext('bunny', 'bunnies', random.randint(1, 2))
    msg6 = ungettext(arg0, 'bunnies', random.randint(1, 2))
    msg7 = _(hello.there)
    msg8 = gettext('Rabbit')
    msg9 = dgettext('wiki', model.addPage())
    msg10 = dngettext(domain, 'Page', 'Pages', 3)
    """)
            messages = \
>               list(extract.extract('python', buf, extract.DEFAULT_KEYWORDS, [],
                                     {}))
E                                    TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:461: TypeError
_ ExtractTestCase.test_warn_if_empty_string_msgid_found_in_context_aware_extraction_method _

self = <tests.messages.test_extract.ExtractTestCase testMethod=test_warn_if_empty_string_msgid_found_in_context_aware_extraction_method>

    def test_warn_if_empty_string_msgid_found_in_context_aware_extraction_method(self):
        buf = BytesIO(b"\nmsg = pgettext('ctxt', '')\n")
        stderr = sys.stderr
        sys.stderr = StringIO()
        try:
            messages = extract.extract('python', buf)
>           assert list(messages) == []
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_extract.py:511: TypeError
_____________________________ test_simple_extract ______________________________

    def test_simple_extract():
        buf = BytesIO(b"""\
    msg1 = _('simple')
    msg2 = gettext('simple')
    msg3 = ngettext('s', 'p', 42)
        """)
        messages = \
>           list(extract.extract('javascript', buf, extract.DEFAULT_KEYWORDS,
                                 [], {}))
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:15: TypeError
______________________________ test_various_calls ______________________________

    def test_various_calls():
        buf = BytesIO(b"""\
    msg1 = _(i18n_arg.replace(/"/, '"'))
    msg2 = ungettext(i18n_arg.replace(/"/, '"'), multi_arg.replace(/"/, '"'), 2)
    msg3 = ungettext("Babel", multi_arg.replace(/"/, '"'), 2)
    msg4 = ungettext(i18n_arg.replace(/"/, '"'), "Babels", 2)
    msg5 = ungettext('bunny', 'bunnies', parseInt(Math.random() * 2 + 1))
    msg6 = ungettext(arg0, 'bunnies', rparseInt(Math.random() * 2 + 1))
    msg7 = _(hello.there)
    msg8 = gettext('Rabbit')
    msg9 = dgettext('wiki', model.addPage())
    msg10 = dngettext(domain, 'Page', 'Pages', 3)
    """)
        messages = \
>           list(extract.extract('javascript', buf, extract.DEFAULT_KEYWORDS, [],
                                 {}))
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:37: TypeError
________________________ test_message_with_line_comment ________________________

    def test_message_with_line_comment():
        buf = BytesIO("""\
    // NOTE: hello
    msg = _('Bonjour à tous')
    """.encode('utf-8'))
>       messages = list(extract.extract_javascript(buf, ('_',), ['NOTE:'], {}))
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:51: TypeError
_____________________ test_message_with_multiline_comment ______________________

    def test_message_with_multiline_comment():
        buf = BytesIO("""\
    /* NOTE: hello
    and bonjour
      and servus */
    msg = _('Bonjour à tous')
    """.encode('utf-8'))
>       messages = list(extract.extract_javascript(buf, ('_',), ['NOTE:'], {}))
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:63: TypeError
_______________________ test_ignore_function_definitions _______________________

    def test_ignore_function_definitions():
        buf = BytesIO(b"""\
    function gettext(value) {
    return translations[language][value] || value;
    }""")
    
>       messages = list(extract.extract_javascript(buf, ('gettext',), [], {}))
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:74: TypeError
___________________________ test_misplaced_comments ____________________________

    def test_misplaced_comments():
        buf = BytesIO(b"""\
    /* NOTE: this won't show up */
    foo()
    
    /* NOTE: this will */
    msg = _('Something')
    
    // NOTE: this will show up
    // too.
    msg = _('Something else')
    
    // NOTE: but this won't
    bar()
    
    _('no comment here')
    """)
>       messages = list(extract.extract_javascript(buf, ('_',), ['NOTE:'], {}))
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:95: TypeError
__________________________ test_jsx_extraction[False] __________________________

jsx_enabled = False

    @pytest.mark.parametrize("jsx_enabled", (False, True))
    def test_jsx_extraction(jsx_enabled):
        buf = BytesIO(JSX_SOURCE)
>       messages = [m[2] for m in extract.extract_javascript(buf, ('_', 'gettext'), [], {"jsx": jsx_enabled})]
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:123: TypeError
__________________________ test_jsx_extraction[True] ___________________________

jsx_enabled = True

    @pytest.mark.parametrize("jsx_enabled", (False, True))
    def test_jsx_extraction(jsx_enabled):
        buf = BytesIO(JSX_SOURCE)
>       messages = [m[2] for m in extract.extract_javascript(buf, ('_', 'gettext'), [], {"jsx": jsx_enabled})]
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:123: TypeError
_________________________ test_dotted_keyword_extract __________________________

    def test_dotted_keyword_extract():
        buf = BytesIO(b"msg1 = com.corporate.i18n.formatMessage('Insert coin to continue')")
>       messages = list(
            extract.extract('javascript', buf, {"com.corporate.i18n.formatMessage": None}, [], {}),
        )
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:132: TypeError
_____________________ test_template_string_standard_usage ______________________

    def test_template_string_standard_usage():
        buf = BytesIO(b"msg1 = gettext(`Very template, wow`)")
>       messages = list(
            extract.extract('javascript', buf, {"gettext": None}, [], {}),
        )
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:141: TypeError
________________________ test_template_string_tag_usage ________________________

    def test_template_string_tag_usage():
        buf = BytesIO(b"function() { if(foo) msg1 = i18n`Tag template, wow`; }")
>       messages = list(
            extract.extract('javascript', buf, {"i18n": None}, [], {}),
        )
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:150: TypeError
_________________________ test_inside_template_string __________________________

    def test_inside_template_string():
        buf = BytesIO(b"const msg = `${gettext('Hello')} ${user.name}`")
>       messages = list(
            extract.extract('javascript', buf, {"gettext": None}, [], {'parse_template_string': True}),
        )
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:159: TypeError
_________________ test_inside_template_string_with_linebreaks __________________

    def test_inside_template_string_with_linebreaks():
        buf = BytesIO(b"""\
    const userName = gettext('Username')
    const msg = `${
    gettext('Hello')
    } ${userName} ${
    gettext('Are you having a nice day?')
    }`
    const msg2 = `${
    gettext('Howdy')
    } ${userName} ${
    gettext('Are you doing ok?')
    }`
    """)
>       messages = list(
            extract.extract('javascript', buf, {"gettext": None}, [], {'parse_template_string': True}),
        )
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:180: TypeError
______________________ test_inside_nested_template_string ______________________

    def test_inside_nested_template_string():
        buf = BytesIO(b"const msg = `${gettext('Greetings!')} ${ evening ? `${user.name}: ${gettext('This is a lovely evening.')}` : `${gettext('The day is really nice!')} ${user.name}`}`")
>       messages = list(
            extract.extract('javascript', buf, {"gettext": None}, [], {'parse_template_string': True}),
        )
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_js_extract.py:189: TypeError
_________________________________ test_unquote _________________________________

    def test_unquote():
>       assert jslexer.unquote_string('""') == ''
E       assert None == ''
E        +  where None = <function unquote_string at 0x77b0e0603880>('""')
E        +    where <function unquote_string at 0x77b0e0603880> = jslexer.unquote_string

tests/messages/test_jslexer.py:5: AssertionError
__________________________ test_dollar_in_identifier ___________________________

    def test_dollar_in_identifier():
>       assert list(jslexer.tokenize('dollar$dollar')) == [('name', 'dollar$dollar', 1)]
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_jslexer.py:12: TypeError
_______________________________ test_dotted_name _______________________________

    def test_dotted_name():
>       assert list(jslexer.tokenize("foo.bar(quux)", dotted=True)) == [
            ('name', 'foo.bar', 1),
            ('operator', '(', 1),
            ('name', 'quux', 1),
            ('operator', ')', 1),
        ]
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_jslexer.py:16: TypeError
_____________________________ test_dotted_name_end _____________________________

    def test_dotted_name_end():
>       assert list(jslexer.tokenize("foo.bar", dotted=True)) == [
            ('name', 'foo.bar', 1),
        ]
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_jslexer.py:25: TypeError
_____________________________ test_template_string _____________________________

    def test_template_string():
>       assert list(jslexer.tokenize("gettext `foo\"bar\"p`", template_string=True)) == [
            ('name', 'gettext', 1),
            ('template_string', '`foo"bar"p`', 1),
        ]
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_jslexer.py:31: TypeError
___________________________________ test_jsx ___________________________________

    def test_jsx():
>       assert list(jslexer.tokenize("""
             <option value="val1">{ i18n._('String1') }</option>
             <option value="val2">{ i18n._('String 2') }</option>
             <option value="val3">{ i18n._('String 3') }</option>
             <component value={i18n._('String 4')} />
             <comp2 prop={<comp3 />} data={{active: true}}>
                 <btn text={ i18n._('String 5') } />
             </comp2>
        """, jsx=True)) == [
            ('jsx_tag', '<option', 2),
            ('name', 'value', 2),
            ('operator', '=', 2),
            ('string', '"val1"', 2),
            ('operator', '>', 2),
            ('operator', '{', 2),
            ('name', 'i18n._', 2),
            ('operator', '(', 2),
            ('string', "'String1'", 2),
            ('operator', ')', 2),
            ('operator', '}', 2),
            ('jsx_tag', '</option', 2),
            ('operator', '>', 2),
            ('jsx_tag', '<option', 3),
            ('name', 'value', 3),
            ('operator', '=', 3),
            ('string', '"val2"', 3),
            ('operator', '>', 3),
            ('operator', '{', 3),
            ('name', 'i18n._', 3),
            ('operator', '(', 3),
            ('string', "'String 2'", 3),
            ('operator', ')', 3),
            ('operator', '}', 3),
            ('jsx_tag', '</option', 3),
            ('operator', '>', 3),
            ('jsx_tag', '<option', 4),
            ('name', 'value', 4),
            ('operator', '=', 4),
            ('string', '"val3"', 4),
            ('operator', '>', 4),
            ('operator', '{', 4),
            ('name', 'i18n._', 4),
            ('operator', '(', 4),
            ('string', "'String 3'", 4),
            ('operator', ')', 4),
            ('operator', '}', 4),
            ('jsx_tag', '</option', 4),
            ('operator', '>', 4),
            ('jsx_tag', '<component', 5),
            ('name', 'value', 5),
            ('operator', '=', 5),
            ('operator', '{', 5),
            ('name', 'i18n._', 5),
            ('operator', '(', 5),
            ('string', "'String 4'", 5),
            ('operator', ')', 5),
            ('operator', '}', 5),
            ('jsx_tag', '/>', 5),
            ('jsx_tag', '<comp2', 6),
            ('name', 'prop', 6),
            ('operator', '=', 6),
            ('operator', '{', 6),
            ('jsx_tag', '<comp3', 6),
            ('jsx_tag', '/>', 6),
            ('operator', '}', 6),
            ('name', 'data', 6),
            ('operator', '=', 6),
            ('operator', '{', 6),
            ('operator', '{', 6),
            ('name', 'active', 6),
            ('operator', ':', 6),
            ('name', 'true', 6),
            ('operator', '}', 6),
            ('operator', '}', 6),
            ('operator', '>', 6),
            ('jsx_tag', '<btn', 7),
            ('name', 'text', 7),
            ('operator', '=', 7),
            ('operator', '{', 7),
            ('name', 'i18n._', 7),
            ('operator', '(', 7),
            ('string', "'String 5'", 7),
            ('operator', ')', 7),
            ('operator', '}', 7),
            ('jsx_tag', '/>', 7),
            ('jsx_tag', '</comp2', 8),
            ('operator', '>', 8),
        ]
E       TypeError: 'NoneType' object is not iterable

tests/messages/test_jslexer.py:38: TypeError
__________________________ ReadMoTestCase.test_basics __________________________

self = <tests.messages.test_mofile.ReadMoTestCase testMethod=test_basics>

    def test_basics(self):
        mo_path = os.path.join(self.datadir, 'project', 'i18n', 'de',
                               'LC_MESSAGES', 'messages.mo')
        with open(mo_path, 'rb') as mo_file:
>           catalog = mofile.read_mo(mo_file)

tests/messages/test_mofile.py:30: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

fileobj = <_io.BufferedReader name='/workspace/babel/tests/messages/data/project/i18n/de/LC_MESSAGES/messages.mo'>

    def read_mo(fileobj):
>       data=pickle.load(fileobj); cat=Catalog(locale=data.get('locale'), domain=data.get('domain','messages'))
E       _pickle.UnpicklingError: invalid load key, '\xde'.

babel/messages/mofile.py:9: UnpicklingError
_____________ WriteMoTestCase.test_empty_translation_with_fallback _____________

self = <tests.messages.test_mofile.WriteMoTestCase testMethod=test_empty_translation_with_fallback>

        def test_empty_translation_with_fallback(self):
            catalog1 = Catalog(locale='fr_FR')
            catalog1.add('', '''\
    "Content-Type: text/plain; charset=utf-8\n"
    "Content-Transfer-Encoding: 8bit\n''')
            catalog1.add('Fuzz', '')
            buf1 = BytesIO()
            mofile.write_mo(buf1, catalog1)
            buf1.seek(0)
            catalog2 = Catalog(locale='fr')
            catalog2.add('', '''\
    "Content-Type: text/plain; charset=utf-8\n"
    "Content-Transfer-Encoding: 8bit\n''')
            catalog2.add('Fuzz', 'Flou')
            buf2 = BytesIO()
            mofile.write_mo(buf2, catalog2)
            buf2.seek(0)
    
            translations = Translations(fp=buf1)
>           translations.add_fallback(Translations(fp=buf2))
E           AttributeError: 'Translations' object has no attribute 'add_fallback'

tests/messages/test_mofile.py:87: AttributeError
_________________________ WriteMoTestCase.test_sorting _________________________

self = <tests.messages.test_mofile.WriteMoTestCase testMethod=test_sorting>

        def test_sorting(self):
            # Ensure the header is sorted to the first entry so that its charset
            # can be applied to all subsequent messages by GNUTranslations
            # (ensuring all messages are safely converted to unicode)
            catalog = Catalog(locale='en_US')
            catalog.add('', '''\
    "Content-Type: text/plain; charset=utf-8\n"
    "Content-Transfer-Encoding: 8bit\n''')
            catalog.add('foo', 'Voh')
            catalog.add(('There is', 'There are'), ('Es gibt', 'Es gibt'))
            catalog.add('Fizz', '')
            catalog.add(('Fuzz', 'Fuzzes'), ('', ''))
            buf = BytesIO()
            mofile.write_mo(buf, catalog)
            buf.seek(0)
            translations = Translations(fp=buf)
            assert translations.ugettext('foo') == 'Voh'
            assert translations.ungettext('There is', 'There are', 1) == 'Es gibt'
>           assert translations.ugettext('Fizz') == 'Fizz'
E           AssertionError: assert '' == 'Fizz'
E             
E             - Fizz

tests/messages/test_mofile.py:58: AssertionError
____________________________ test_normalized_string ____________________________

    def test_normalized_string():
>       ab1 = _NormalizedString('a', 'b ')

tests/messages/test_normalized_string.py:5: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = , args = ('a', 'b '), arg = 'a'

    def __init__(self, *args: str) -> None:
        self._strs: list[str] = []
        for arg in args:
>           self.append(arg)
E           AttributeError: '_NormalizedString' object has no attribute 'append'

babel/messages/pofile.py:73: AttributeError
__________________ ReadPoTestCase.test_abort_invalid_po_file ___________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_abort_invalid_po_file>

    def test_abort_invalid_po_file(self):
        invalid_po = '''
            msgctxt ""
            "{\"checksum\": 2148532640, \"cxt\": \"collector_thankyou\", \"id\": "
            "270005359}"
            msgid ""
            "Thank you very much for your time.\n"
            "If you have any questions regarding this survey, please contact Fulano "
            "at nadie@blah.com"
            msgstr "Merci de prendre le temps de remplir le sondage.
            Pour toute question, veuillez communiquer avec Fulano  à nadie@blah.com
            "
        '''
        invalid_po_2 = '''
            msgctxt ""
            "{\"checksum\": 2148532640, \"cxt\": \"collector_thankyou\", \"id\": "
            "270005359}"
            msgid ""
            "Thank you very much for your time.\n"
            "If you have any questions regarding this survey, please contact Fulano "
            "at fulano@blah.com."
            msgstr "Merci de prendre le temps de remplir le sondage.
            Pour toute question, veuillez communiquer avec Fulano a fulano@blah.com
            "
            '''
        # Catalog not created, throws Unicode Error
        buf = StringIO(invalid_po)
        output = pofile.read_po(buf, locale='fr', abort_invalid=False)
>       assert isinstance(output, Catalog)
E       assert False
E        +  where False = isinstance(None, Catalog)

tests/messages/test_pofile.py:469: AssertionError
__________ ReadPoTestCase.test_applies_specified_encoding_during_read __________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_applies_specified_encoding_during_read>

        def test_applies_specified_encoding_during_read(self):
            buf = BytesIO('''
    msgid ""
    msgstr ""
    "Project-Id-Version:  3.15\\n"
    "Report-Msgid-Bugs-To: Fliegender Zirkus <fliegender@zirkus.de>\\n"
    "POT-Creation-Date: 2007-09-27 11:19+0700\\n"
    "PO-Revision-Date: 2007-09-27 21:42-0700\\n"
    "Last-Translator: John <cleese@bavaria.de>\\n"
    "Language-Team: German Lang <de@babel.org>\\n"
    "Plural-Forms: nplurals=2; plural=(n != 1);\\n"
    "MIME-Version: 1.0\\n"
    "Content-Type: text/plain; charset=iso-8859-1\\n"
    "Content-Transfer-Encoding: 8bit\\n"
    "Generated-By: Babel 1.0dev-r313\\n"
    
    msgid "foo"
    msgstr "bär"'''.encode('iso-8859-1'))
            catalog = pofile.read_po(buf, locale='de_DE')
>           assert catalog.get('foo').string == 'bär'
E           AttributeError: 'NoneType' object has no attribute 'get'

tests/messages/test_pofile.py:72: AttributeError
___________________ ReadPoTestCase.test_encoding_header_read ___________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_encoding_header_read>

    def test_encoding_header_read(self):
        buf = BytesIO(b'msgid ""\nmsgstr ""\n"Content-Type: text/plain; charset=mac_roman\\n"\n')
        catalog = pofile.read_po(buf, locale='xx_XX')
>       assert catalog.charset == 'mac_roman'
E       AttributeError: 'NoneType' object has no attribute 'charset'

tests/messages/test_pofile.py:77: AttributeError
_______________________ ReadPoTestCase.test_fuzzy_header _______________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_fuzzy_header>

        def test_fuzzy_header(self):
            buf = StringIO(r'''
    # Translations template for AReallyReallyLongNameForAProject.
    # Copyright (C) 2007 ORGANIZATION
    # This file is distributed under the same license as the
    # AReallyReallyLongNameForAProject project.
    # FIRST AUTHOR <EMAIL@ADDRESS>, 2007.
    #
    #, fuzzy
    ''')
            catalog = pofile.read_po(buf)
>           assert len(list(catalog)) == 1
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_pofile.py:111: TypeError
_______________________ ReadPoTestCase.test_header_entry _______________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_header_entry>

        def test_header_entry(self):
            buf = StringIO(r'''
    # SOME DESCRIPTIVE TITLE.
    # Copyright (C) 2007 THE PACKAGE'S COPYRIGHT HOLDER
    # This file is distributed under the same license as the PACKAGE package.
    # FIRST AUTHOR <EMAIL@ADDRESS>, 2007.
    #
    #, fuzzy
    msgid ""
    msgstr ""
    "Project-Id-Version:  3.15\n"
    "Report-Msgid-Bugs-To: Fliegender Zirkus <fliegender@zirkus.de>\n"
    "POT-Creation-Date: 2007-09-27 11:19+0700\n"
    "PO-Revision-Date: 2007-09-27 21:42-0700\n"
    "Last-Translator: John <cleese@bavaria.de>\n"
    "Language: de\n"
    "Language-Team: German Lang <de@babel.org>\n"
    "Plural-Forms: nplurals=2; plural=(n != 1);\n"
    "MIME-Version: 1.0\n"
    "Content-Type: text/plain; charset=iso-8859-2\n"
    "Content-Transfer-Encoding: 8bit\n"
    "Generated-By: Babel 1.0dev-r313\n"
    ''')
            catalog = pofile.read_po(buf)
>           assert len(list(catalog)) == 1
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_pofile.py:151: TypeError
______________ ReadPoTestCase.test_invalid_pofile_with_abort_flag ______________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_invalid_pofile_with_abort_flag>

    def test_invalid_pofile_with_abort_flag(self):
>       parser = pofile.PoFileParser(None, abort_invalid=True)

tests/messages/test_pofile.py:487: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <babel.messages.pofile.PoFileParser object at 0x77b0dfc347c0>
catalog = None, ignore_obsolete = False, abort_invalid = True

    def __init__(self, catalog: Catalog, ignore_obsolete: bool=False, abort_invalid: bool=False) -> None:
        self.catalog = catalog
        self.ignore_obsolete = ignore_obsolete
        self.counter = 0
        self.offset = 0
        self.abort_invalid = abort_invalid
>       self._reset_message_state()
E       AttributeError: 'PoFileParser' object has no attribute '_reset_message_state'

babel/messages/pofile.py:118: AttributeError
______________ ReadPoTestCase.test_locale_gets_overridden_by_file ______________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_locale_gets_overridden_by_file>

        def test_locale_gets_overridden_by_file(self):
            buf = StringIO(r'''
    msgid ""
    msgstr ""
    "Language: en_US\n"''')
            catalog = pofile.read_po(buf, locale='de')
>           assert Locale('en', 'US') == catalog.locale
E           AttributeError: 'NoneType' object has no attribute 'locale'

tests/messages/test_pofile.py:39: AttributeError
______________________ ReadPoTestCase.test_missing_plural ______________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_missing_plural>

        def test_missing_plural(self):
            buf = StringIO('''\
    msgid ""
    msgstr ""
    "Plural-Forms: nplurals=3; plural=(n < 2) ? n : 2;\n"
    
    msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh [text]"
    msgstr[1] "Vohs [text]"
    ''')
            catalog = pofile.read_po(buf, locale='nb_NO')
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:413: TypeError
_______________ ReadPoTestCase.test_missing_plural_in_the_middle _______________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_missing_plural_in_the_middle>

        def test_missing_plural_in_the_middle(self):
            buf = StringIO('''\
    msgid ""
    msgstr ""
    "Plural-Forms: nplurals=3; plural=(n < 2) ? n : 2;\n"
    
    msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh [text]"
    msgstr[2] "Vohs [text]"
    ''')
            catalog = pofile.read_po(buf, locale='nb_NO')
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:433: TypeError
________________ ReadPoTestCase.test_more_than_two_plural_forms ________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_more_than_two_plural_forms>

        def test_more_than_two_plural_forms(self):
            buf = StringIO(r'''msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh"
    msgstr[1] "Vohs"
    msgstr[2] "Vohss"''')
            catalog = pofile.read_po(buf, locale='lv_LV')
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:368: TypeError
_______________ ReadPoTestCase.test_multi_line_obsolete_message ________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_multi_line_obsolete_message>

        def test_multi_line_obsolete_message(self):
            buf = StringIO(r'''# This is an obsolete message
    #~ msgid ""
    #~ "foo"
    #~ "foo"
    #~ msgstr ""
    #~ "Voh"
    #~ "Vooooh"
    
    # This message is not obsolete
    #: main.py:1
    msgid "bar"
    msgstr "Bahr"
    ''')
            catalog = pofile.read_po(buf)
>           assert len(catalog.obsolete) == 1
E           AttributeError: 'NoneType' object has no attribute 'obsolete'

tests/messages/test_pofile.py:208: AttributeError
____________________ ReadPoTestCase.test_multiline_context _____________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_multiline_context>

        def test_multiline_context(self):
            buf = StringIO('''
    msgctxt "a really long "
    "message context "
    "why?"
    msgid "mid"
    msgstr "mst"
            ''')
            catalog = pofile.read_po(buf)
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:314: TypeError
_____________________ ReadPoTestCase.test_not_fuzzy_header _____________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_not_fuzzy_header>

        def test_not_fuzzy_header(self):
            buf = StringIO(r'''
    # Translations template for AReallyReallyLongNameForAProject.
    # Copyright (C) 2007 ORGANIZATION
    # This file is distributed under the same license as the
    # AReallyReallyLongNameForAProject project.
    # FIRST AUTHOR <EMAIL@ADDRESS>, 2007.
    #
    ''')
            catalog = pofile.read_po(buf)
>           assert len(list(catalog)) == 1
E           TypeError: 'NoneType' object is not iterable

tests/messages/test_pofile.py:124: TypeError
_____________________ ReadPoTestCase.test_obsolete_message _____________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_obsolete_message>

        def test_obsolete_message(self):
            buf = StringIO(r'''# This is an obsolete message
    #~ msgid "foo"
    #~ msgstr "Voh"
    
    # This message is not obsolete
    #: main.py:1
    msgid "bar"
    msgstr "Bahr"
    ''')
            catalog = pofile.read_po(buf)
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:172: TypeError
_________________ ReadPoTestCase.test_obsolete_message_ignored _________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_obsolete_message_ignored>

        def test_obsolete_message_ignored(self):
            buf = StringIO(r'''# This is an obsolete message
    #~ msgid "foo"
    #~ msgstr "Voh"
    
    # This message is not obsolete
    #: main.py:1
    msgid "bar"
    msgstr "Bahr"
    ''')
            catalog = pofile.read_po(buf, ignore_obsolete=True)
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:190: TypeError
______________ ReadPoTestCase.test_obsolete_message_with_context _______________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_obsolete_message_with_context>

        def test_obsolete_message_with_context(self):
            buf = StringIO('''
    # This message is not obsolete
    msgid "baz"
    msgstr "Bazczch"
    
    # This is an obsolete message
    #~ msgctxt "other"
    #~ msgid "foo"
    #~ msgstr "Voh"
    
    # This message is not obsolete
    #: main.py:1
    msgid "bar"
    msgstr "Bahr"
    ''')
            catalog = pofile.read_po(buf)
>           assert len(catalog) == 2
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:299: TypeError
___________ ReadPoTestCase.test_obsolete_plural_with_square_brackets ___________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_obsolete_plural_with_square_brackets>

        def test_obsolete_plural_with_square_brackets(self):
            buf = StringIO('''\
    #~ msgid "foo"
    #~ msgid_plural "foos"
    #~ msgstr[0] "Voh [text]"
    #~ msgstr[1] "Vohs [text]"
    ''')
            catalog = pofile.read_po(buf, locale='nb_NO')
>           assert len(catalog) == 0
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:393: TypeError
________________ ReadPoTestCase.test_plural_forms_header_parsed ________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_plural_forms_header_parsed>

    def test_plural_forms_header_parsed(self):
        buf = BytesIO(b'msgid ""\nmsgstr ""\n"Plural-Forms: nplurals=42; plural=(n % 11);\\n"\n')
        catalog = pofile.read_po(buf, locale='xx_XX')
>       assert catalog.plural_expr == '(n % 11)'
E       AttributeError: 'NoneType' object has no attribute 'plural_expr'

tests/messages/test_pofile.py:82: AttributeError
_______________ ReadPoTestCase.test_plural_with_square_brackets ________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_plural_with_square_brackets>

        def test_plural_with_square_brackets(self):
            buf = StringIO(r'''msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh [text]"
    msgstr[1] "Vohs [text]"''')
            catalog = pofile.read_po(buf, locale='nb_NO')
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:380: TypeError
_____________________ ReadPoTestCase.test_preserve_domain ______________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_preserve_domain>

        def test_preserve_domain(self):
            buf = StringIO(r'''msgid "foo"
    msgstr "Voh"''')
            catalog = pofile.read_po(buf, domain='mydomain')
>           assert catalog.domain == 'mydomain'
E           AttributeError: 'NoneType' object has no attribute 'domain'

tests/messages/test_pofile.py:51: AttributeError
_____________________ ReadPoTestCase.test_preserve_locale ______________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_preserve_locale>

        def test_preserve_locale(self):
            buf = StringIO(r'''msgid "foo"
    msgstr "Voh"''')
            catalog = pofile.read_po(buf, locale='en_US')
>           assert Locale('en', 'US') == catalog.locale
E           AttributeError: 'NoneType' object has no attribute 'locale'

tests/messages/test_pofile.py:31: AttributeError
______________________ ReadPoTestCase.test_read_multiline ______________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_read_multiline>

        def test_read_multiline(self):
            buf = StringIO(r'''msgid ""
    "Here's some text that\n"
    "includesareallylongwordthatmightbutshouldnt"
    " throw us into an infinite "
    "loop\n"
    msgstr ""''')
            catalog = pofile.read_po(buf)
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:93: TypeError
____________________ ReadPoTestCase.test_single_plural_form ____________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_single_plural_form>

        def test_single_plural_form(self):
            buf = StringIO(r'''msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh"''')
            catalog = pofile.read_po(buf, locale='ja_JP')
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:345: TypeError
___________________ ReadPoTestCase.test_singular_plural_form ___________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_singular_plural_form>

        def test_singular_plural_form(self):
            buf = StringIO(r'''msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh"
    msgstr[1] "Vohs"''')
            catalog = pofile.read_po(buf, locale='nl_NL')
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:356: TypeError
__________ ReadPoTestCase.test_unit_before_obsolete_is_not_obsoleted ___________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_unit_before_obsolete_is_not_obsoleted>

        def test_unit_before_obsolete_is_not_obsoleted(self):
            buf = StringIO(r'''
    # This message is not obsolete
    #: main.py:1
    msgid "bar"
    msgstr "Bahr"
    
    # This is an obsolete message
    #~ msgid ""
    #~ "foo"
    #~ "fooooooo"
    #~ msgstr ""
    #~ "Voh"
    #~ "Vooooh"
    ''')
            catalog = pofile.read_po(buf)
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:251: TypeError
________ ReadPoTestCase.test_unit_following_multi_line_obsolete_message ________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_unit_following_multi_line_obsolete_message>

        def test_unit_following_multi_line_obsolete_message(self):
            buf = StringIO(r'''# This is an obsolete message
    #~ msgid ""
    #~ "foo"
    #~ "fooooooo"
    #~ msgstr ""
    #~ "Voh"
    #~ "Vooooh"
    
    # This message is not obsolete
    #: main.py:1
    msgid "bar"
    msgstr "Bahr"
    ''')
            catalog = pofile.read_po(buf)
>           assert len(catalog) == 1
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:229: TypeError
_______________________ ReadPoTestCase.test_with_context _______________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_with_context>

        def test_with_context(self):
            buf = BytesIO(b'''# Some string in the menu
    #: main.py:1
    msgctxt "Menu"
    msgid "foo"
    msgstr "Voh"
    
    # Another string in the menu
    #: main.py:2
    msgctxt "Menu"
    msgid "bar"
    msgstr "Bahr"
    ''')
            catalog = pofile.read_po(buf, ignore_obsolete=True)
>           assert len(catalog) == 2
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:271: TypeError
_____________________ ReadPoTestCase.test_with_context_two _____________________

self = <tests.messages.test_pofile.ReadPoTestCase testMethod=test_with_context_two>

        def test_with_context_two(self):
            buf = BytesIO(b'''msgctxt "Menu"
    msgid "foo"
    msgstr "Voh"
    
    msgctxt "Mannu"
    msgid "bar"
    msgstr "Bahr"
    ''')
            catalog = pofile.read_po(buf, ignore_obsolete=True)
>           assert len(catalog) == 2
E           TypeError: object of type 'NoneType' has no len()

tests/messages/test_pofile.py:329: TypeError
___________________ WritePoTestCase.test_duplicate_comments ____________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_duplicate_comments>

        def test_duplicate_comments(self):
            catalog = Catalog()
            catalog.add('foo', auto_comments=['A comment'])
            catalog.add('foo', auto_comments=['A comment'])
            buf = BytesIO()
            pofile.write_po(buf, catalog, omit_header=True)
>           assert buf.getvalue().strip() == b'''#. A comment
    msgid "foo"
    msgstr ""'''
E   assert b'' == b'#. A commen...o"\nmsgstr ""'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:522: AssertionError
_____________________ WritePoTestCase.test_file_sorted_po ______________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_file_sorted_po>

    def test_file_sorted_po(self):
        catalog = Catalog()
        catalog.add('bar', locations=[('utils.py', 3)])
        catalog.add(('foo', 'foos'), ('Voh', 'Voeh'), locations=[('main.py', 1)])
        buf = BytesIO()
        pofile.write_po(buf, catalog, sort_by_file=True)
        value = buf.getvalue().strip()
>       assert value.find(b'main.py') < value.find(b'utils.py')
E       AssertionError: assert -1 < -1
E        +  where -1 = <built-in method find of bytes object at 0x77b0e1f5c030>(b'main.py')
E        +    where <built-in method find of bytes object at 0x77b0e1f5c030> = b''.find
E        +  and   -1 = <built-in method find of bytes object at 0x77b0e1f5c030>(b'utils.py')
E        +    where <built-in method find of bytes object at 0x77b0e1f5c030> = b''.find

tests/messages/test_pofile.py:793: AssertionError
___________________ WritePoTestCase.test_file_with_no_lineno ___________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_file_with_no_lineno>

        def test_file_with_no_lineno(self):
            catalog = Catalog()
            catalog.add('bar', locations=[('utils.py', None)],
                        user_comments=['Comment About `bar` with',
                                       'multiple lines.'])
            buf = BytesIO()
            pofile.write_po(buf, catalog, sort_output=True)
            value = buf.getvalue().strip()
>           assert b'''\
    # Comment About `bar` with
    # multiple lines.
    #: utils.py
    msgid "bar"
    msgstr ""''' in value
E   assert b'# Comment About `bar` with\n# multiple lines.\n#: utils.py\nmsgid "bar"\nmsgstr ""' in b''

tests/messages/test_pofile.py:803: AssertionError
_____________________ WritePoTestCase.test_include_lineno ______________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_include_lineno>

        def test_include_lineno(self):
            catalog = Catalog()
            catalog.add('foo', locations=[('main.py', 1)])
            catalog.add('foo', locations=[('utils.py', 3)])
            buf = BytesIO()
            pofile.write_po(buf, catalog, omit_header=True, include_lineno=True)
>           assert buf.getvalue().strip() == b'''#: main.py:1 utils.py:3
    msgid "foo"
    msgstr ""'''
E   assert b'' == b'#: main.py:...o"\nmsgstr ""'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:829: AssertionError
_____________________ WritePoTestCase.test_join_locations ______________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_join_locations>

        def test_join_locations(self):
            catalog = Catalog()
            catalog.add('foo', locations=[('main.py', 1)])
            catalog.add('foo', locations=[('utils.py', 3)])
            buf = BytesIO()
            pofile.write_po(buf, catalog, omit_header=True)
>           assert buf.getvalue().strip() == b'''#: main.py:1 utils.py:3
    msgid "foo"
    msgstr ""'''
E   assert b'' == b'#: main.py:...o"\nmsgstr ""'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:503: AssertionError
____________________ WritePoTestCase.test_no_include_lineno ____________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_no_include_lineno>

        def test_no_include_lineno(self):
            catalog = Catalog()
            catalog.add('foo', locations=[('main.py', 1)])
            catalog.add('foo', locations=[('main.py', 2)])
            catalog.add('foo', locations=[('utils.py', 3)])
            buf = BytesIO()
            pofile.write_po(buf, catalog, omit_header=True, include_lineno=False)
>           assert buf.getvalue().strip() == b'''#: main.py utils.py
    msgid "foo"
    msgstr ""'''
E   assert b'' == b'#: main.py ...o"\nmsgstr ""'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:840: AssertionError
_________ WritePoTestCase.test_no_wrap_and_width_behaviour_on_comments _________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_no_wrap_and_width_behaviour_on_comments>

        def test_no_wrap_and_width_behaviour_on_comments(self):
            catalog = Catalog()
            catalog.add("Pretty dam long message id, which must really be big "
                        "to test this wrap behaviour, if not it won't work.",
                        locations=[("fake.py", n) for n in range(1, 30)])
            buf = BytesIO()
            pofile.write_po(buf, catalog, width=None, omit_header=True)
>           assert buf.getvalue().lower() == b"""\
    #: fake.py:1 fake.py:2 fake.py:3 fake.py:4 fake.py:5 fake.py:6 fake.py:7
    #: fake.py:8 fake.py:9 fake.py:10 fake.py:11 fake.py:12 fake.py:13 fake.py:14
    #: fake.py:15 fake.py:16 fake.py:17 fake.py:18 fake.py:19 fake.py:20 fake.py:21
    #: fake.py:22 fake.py:23 fake.py:24 fake.py:25 fake.py:26 fake.py:27 fake.py:28
    #: fake.py:29
    msgid "pretty dam long message id, which must really be big to test this wrap behaviour, if not it won't work."
    msgstr ""
    
    """
E   assert b'' == b'#: fake.py:...msgstr ""\n\n'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:602: AssertionError
___________ WritePoTestCase.test_po_with_multiline_obsolete_message ____________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_po_with_multiline_obsolete_message>

        def test_po_with_multiline_obsolete_message(self):
            catalog = Catalog()
            catalog.add('foo', 'Voh', locations=[('main.py', 1)])
            msgid = r"""Here's a message that covers
    multiple lines, and should still be handled
    correctly.
    """
            msgstr = r"""Here's a message that covers
    multiple lines, and should still be handled
    correctly.
    """
>           catalog.obsolete[msgid] = Message(msgid, msgstr,
                                              locations=[('utils.py', 3)])
E                                             AttributeError: 'Catalog' object has no attribute 'obsolete'

tests/messages/test_pofile.py:673: AttributeError
________________ WritePoTestCase.test_po_with_obsolete_message _________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_po_with_obsolete_message>

    def test_po_with_obsolete_message(self):
        catalog = Catalog()
        catalog.add('foo', 'Voh', locations=[('main.py', 1)])
>       catalog.obsolete['bar'] = Message('bar', 'Bahr',
                                          locations=[('utils.py', 3)],
                                          user_comments=['User comment'])
E       AttributeError: 'Catalog' object has no attribute 'obsolete'

tests/messages/test_pofile.py:649: AttributeError
____________ WritePoTestCase.test_po_with_obsolete_message_ignored _____________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_po_with_obsolete_message_ignored>

    def test_po_with_obsolete_message_ignored(self):
        catalog = Catalog()
        catalog.add('foo', 'Voh', locations=[('main.py', 1)])
>       catalog.obsolete['bar'] = Message('bar', 'Bahr',
                                          locations=[('utils.py', 3)],
                                          user_comments=['User comment'])
E       AttributeError: 'Catalog' object has no attribute 'obsolete'

tests/messages/test_pofile.py:693: AttributeError
_________________ WritePoTestCase.test_po_with_previous_msgid __________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_po_with_previous_msgid>

        def test_po_with_previous_msgid(self):
            catalog = Catalog()
            catalog.add('foo', 'Voh', locations=[('main.py', 1)],
                        previous_id='fo')
            buf = BytesIO()
            pofile.write_po(buf, catalog, omit_header=True, include_previous=True)
>           assert buf.getvalue().strip() == b'''#: main.py:1
    #| msgid "fo"
    msgid "foo"
    msgstr "Voh"'''
E   assert b'' == b'#: main.py:...nmsgstr "Voh"'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:708: AssertionError
______________ WritePoTestCase.test_po_with_previous_msgid_plural ______________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_po_with_previous_msgid_plural>

        def test_po_with_previous_msgid_plural(self):
            catalog = Catalog()
            catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
                        locations=[('main.py', 1)], previous_id=('fo', 'fos'))
            buf = BytesIO()
            pofile.write_po(buf, catalog, omit_header=True, include_previous=True)
>           assert buf.getvalue().strip() == b'''#: main.py:1
    #| msgid "fo"
    #| msgid_plural "fos"
    msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh"
    msgstr[1] "Voeh"'''
E   assert b'' == b'#: main.py:...str[1] "Voeh"'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:719: AssertionError
______________ WritePoTestCase.test_pot_with_translator_comments _______________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_pot_with_translator_comments>

        def test_pot_with_translator_comments(self):
            catalog = Catalog()
            catalog.add('foo', locations=[('main.py', 1)],
                        auto_comments=['Comment About `foo`'])
            catalog.add('bar', locations=[('utils.py', 3)],
                        user_comments=['Comment About `bar` with',
                                       'multiple lines.'])
            buf = BytesIO()
            pofile.write_po(buf, catalog, omit_header=True)
>           assert buf.getvalue().strip() == b'''#. Comment About `foo`
    #: main.py:1
    msgid "foo"
    msgstr ""
    
    # Comment About `bar` with
    # multiple lines.
    #: utils.py:3
    msgid "bar"
    msgstr ""'''
E   assert b'' == b'#. Comment ...r"\nmsgstr ""'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:635: AssertionError
________________ WritePoTestCase.test_silent_location_fallback _________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_silent_location_fallback>

        def test_silent_location_fallback(self):
            buf = BytesIO(b'''\
    #: broken_file.py
    msgid "missing line number"
    msgstr ""
    
    #: broken_file.py:broken_line_number
    msgid "broken line number"
    msgstr ""''')
            catalog = pofile.read_po(buf)
>           assert catalog['missing line number'].locations == [('broken_file.py', None)]
E           TypeError: 'NoneType' object is not subscriptable

tests/messages/test_pofile.py:820: TypeError
________________________ WritePoTestCase.test_sorted_po ________________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_sorted_po>

        def test_sorted_po(self):
            catalog = Catalog()
            catalog.add('bar', locations=[('utils.py', 3)],
                        user_comments=['Comment About `bar` with',
                                       'multiple lines.'])
            catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
                        locations=[('main.py', 1)])
            buf = BytesIO()
            pofile.write_po(buf, catalog, sort_output=True)
            value = buf.getvalue().strip()
>           assert b'''\
    # Comment About `bar` with
    # multiple lines.
    #: utils.py:3
    msgid "bar"
    msgstr ""
    
    #: main.py:1
    msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh"
    msgstr[1] "Voeh"''' in value
E   assert b'# Comment About `bar` with\n# multiple lines.\n#: utils.py:3\nmsgid "bar"\nmsgstr ""\n\n#: main.py:1\nmsgid "foo"\nmsgid_plural "foos"\nmsgstr[0] "Voh"\nmsgstr[1] "Voeh"' in b''

tests/messages/test_pofile.py:737: AssertionError
____________________ WritePoTestCase.test_sorted_po_context ____________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_sorted_po_context>

        def test_sorted_po_context(self):
            catalog = Catalog()
            catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
                        locations=[('main.py', 1)],
                        context='there')
            catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
                        locations=[('main.py', 1)])
            catalog.add(('foo', 'foos'), ('Voh', 'Voeh'),
                        locations=[('main.py', 1)],
                        context='here')
            buf = BytesIO()
            pofile.write_po(buf, catalog, sort_output=True)
            value = buf.getvalue().strip()
            # We expect the foo without ctx, followed by "here" foo and "there" foo
>           assert b'''\
    #: main.py:1
    msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh"
    msgstr[1] "Voeh"
    
    #: main.py:1
    msgctxt "here"
    msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh"
    msgstr[1] "Voeh"
    
    #: main.py:1
    msgctxt "there"
    msgid "foo"
    msgid_plural "foos"
    msgstr[0] "Voh"
    msgstr[1] "Voeh"''' in value
E   assert b'#: main.py:1\nmsgid "foo"\nmsgid_plural "foos"\nmsgstr[0] "Voh"\nmsgstr[1] "Voeh"\n\n#: main.py:1\nmsgctxt "here"\nm...msgstr[1] "Voeh"\n\n#: main.py:1\nmsgctxt "there"\nmsgid "foo"\nmsgid_plural "foos"\nmsgstr[0] "Voh"\nmsgstr[1] "Voeh"' in b''

tests/messages/test_pofile.py:765: AssertionError
_______________ WritePoTestCase.test_wrap_locations_with_hyphens _______________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_wrap_locations_with_hyphens>

        def test_wrap_locations_with_hyphens(self):
            catalog = Catalog()
            catalog.add('foo', locations=[
                ('doupy/templates/base/navmenu.inc.html.py', 60),
            ])
            catalog.add('foo', locations=[
                ('doupy/templates/job-offers/helpers.html', 22),
            ])
            buf = BytesIO()
            pofile.write_po(buf, catalog, omit_header=True)
>           assert buf.getvalue().strip() == b'''#: doupy/templates/base/navmenu.inc.html.py:60
    #: doupy/templates/job-offers/helpers.html:22
    msgid "foo"
    msgstr ""'''
E   assert b'' == b'#: doupy/te...o"\nmsgstr ""'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:590: AssertionError
_____________________ WritePoTestCase.test_wrap_long_lines _____________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_wrap_long_lines>

        def test_wrap_long_lines(self):
            text = """Here's some text where
    white space and line breaks matter, and should
    
    not be removed
    
    """
            catalog = Catalog()
            catalog.add(text, locations=[('main.py', 1)])
            buf = BytesIO()
            pofile.write_po(buf, catalog, no_location=True, omit_header=True,
                            width=42)
>           assert buf.getvalue().strip() == b'''msgid ""
    "Here's some text where\\n"
    "white space and line breaks matter, and"
    " should\\n"
    "\\n"
    "not be removed\\n"
    "\\n"
    msgstr ""'''
E   assert b'' == b'msgid ""\n"...n"\nmsgstr ""'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:538: AssertionError
________________ WritePoTestCase.test_wrap_long_lines_in_header ________________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_wrap_long_lines_in_header>

    def test_wrap_long_lines_in_header(self):
        """
        Verify that long lines in the header comment are wrapped correctly.
        """
        catalog = Catalog(project='AReallyReallyLongNameForAProject',
                          revision_date=datetime(2007, 4, 1))
        buf = BytesIO()
        pofile.write_po(buf, catalog)
>       assert b'\n'.join(buf.getvalue().splitlines()[:7]) == b'''\
E       AssertionError: assert b'' == b'# Translati...\n#\n#, fuzzy'
E         
E         Use -v to get more diff

tests/messages/test_pofile.py:571: AssertionError
_____________ WritePoTestCase.test_wrap_long_lines_with_long_word ______________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_wrap_long_lines_with_long_word>

        def test_wrap_long_lines_with_long_word(self):
            text = """Here's some text that
    includesareallylongwordthatmightbutshouldnt throw us into an infinite loop
    """
            catalog = Catalog()
            catalog.add(text, locations=[('main.py', 1)])
            buf = BytesIO()
            pofile.write_po(buf, catalog, no_location=True, omit_header=True,
                            width=32)
>           assert buf.getvalue().strip() == b'''msgid ""
    "Here's some text that\\n"
    "includesareallylongwordthatmightbutshouldnt"
    " throw us into an infinite "
    "loop\\n"
    msgstr ""'''
E   assert b'' == b'msgid ""\n"...n"\nmsgstr ""'
E     
E     Use -v to get more diff

tests/messages/test_pofile.py:556: AssertionError
__________ WritePoTestCase.test_write_po_file_with_specified_charset ___________

self = <tests.messages.test_pofile.WritePoTestCase testMethod=test_write_po_file_with_specified_charset>

    def test_write_po_file_with_specified_charset(self):
        catalog = Catalog(charset='iso-8859-1')
        catalog.add('foo', 'äöü', locations=[('main.py', 1)])
        buf = BytesIO()
        pofile.write_po(buf, catalog, omit_header=False)
        po_file = buf.getvalue().strip()
>       assert b'"Content-Type: text/plain; charset=iso-8859-1\\n"' in po_file
E       assert b'"Content-Type: text/plain; charset=iso-8859-1\\n"' in b''

tests/messages/test_pofile.py:513: AssertionError
_ PofileFunctionsTestCase.test_denormalize_on_msgstr_without_empty_first_line __

self = <tests.messages.test_pofile.PofileFunctionsTestCase testMethod=test_denormalize_on_msgstr_without_empty_first_line>

    def test_denormalize_on_msgstr_without_empty_first_line(self):
        # handle irregular multi-line msgstr (no "" as first line)
        # gracefully (#171)
        msgstr = '"multi-line\\n"\n" translation"'
        expected_denormalized = 'multi-line\n translation'
    
>       assert expected_denormalized == pofile.denormalize(msgstr)
E       assert 'multi-line\n translation' == None
E        +  where None = <function denormalize at 0x77b0e068a440>('"multi-line\\n"\n" translation"')
E        +    where <function denormalize at 0x77b0e068a440> = pofile.denormalize

tests/messages/test_pofile.py:863: AssertionError
____________________ PofileFunctionsTestCase.test_unescape _____________________

self = <tests.messages.test_pofile.PofileFunctionsTestCase testMethod=test_unescape>

    def test_unescape(self):
        escaped = '"Say:\\n  \\"hello, world!\\"\\n"'
        unescaped = 'Say:\n  "hello, world!"\n'
        assert unescaped != escaped
>       assert unescaped == pofile.unescape(escaped)
E       assert 'Say:\n  "hello, world!"\n' == None
E        +  where None = <function unescape at 0x77b0e0688c10>('"Say:\\n  \\"hello, world!\\"\\n"')
E        +    where <function unescape at 0x77b0e0688c10> = pofile.unescape

tests/messages/test_pofile.py:851: AssertionError
___________ PofileFunctionsTestCase.test_unescape_of_quoted_newline ____________

self = <tests.messages.test_pofile.PofileFunctionsTestCase testMethod=test_unescape_of_quoted_newline>

    def test_unescape_of_quoted_newline(self):
        # regression test for #198
>       assert pofile.unescape(r'"\\n"') == '\\n'
E       assert None == '\\n'
E        +  where None = <function unescape at 0x77b0e0688c10>('"\\\\n"')
E        +    where <function unescape at 0x77b0e0688c10> = pofile.unescape

tests/messages/test_pofile.py:855: AssertionError
_______________________ test_unknown_language_roundtrip ________________________

    def test_unknown_language_roundtrip():
        buf = StringIO(r'''
    msgid ""
    msgstr ""
    "Language: sr_SP\n"''')
        catalog = pofile.read_po(buf)
>       assert catalog.locale_identifier == 'sr_SP'
E       AttributeError: 'NoneType' object has no attribute 'locale_identifier'

tests/messages/test_pofile.py:873: AttributeError
_________________________ test_unknown_language_write __________________________

    def test_unknown_language_write():
        catalog = Catalog(locale='sr_SP')
>       assert catalog.locale_identifier == 'sr_SP'
E       AttributeError: 'Catalog' object has no attribute 'locale_identifier'

tests/messages/test_pofile.py:882: AttributeError
____________ test_extract_distutils_keyword_arg_388[LW_-expected0] _____________

kwarg = 'LW_', expected = ('LW_',)

    @pytest.mark.parametrize("kwarg,expected", [
        ("LW_", ("LW_",)),
        ("LW_ QQ Q", ("LW_", "QQ", "Q")),
        ("yiy         aia", ("yiy", "aia")),
    ])
    def test_extract_distutils_keyword_arg_388(kwarg, expected):
>       from babel.messages import frontend, setuptools_frontend

tests/messages/test_setuptools_frontend.py:21: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

    """
        babel.messages.frontend
        ~~~~~~~~~~~~~~~~~~~~~~~
    
        Frontends for the message extraction functionality.
    
        :copyright: (c) 2013-2023 by the Babel Team.
        :license: BSD, see LICENSE for more details.
    """
    from __future__ import annotations
    import datetime
    import fnmatch
    import logging
    import optparse
    import os
    import re
    import shutil
    import sys
    import tempfile
    from collections import OrderedDict
    from configparser import RawConfigParser
    from io import StringIO
    from typing import Iterable
    from babel import Locale, localedata
    from babel import __version__ as VERSION
    from babel.core import UnknownLocaleError
>   from babel.messages.catalog import DEFAULT_HEADER, Catalog
E   ImportError: cannot import name 'DEFAULT_HEADER' from 'babel.messages.catalog' (/workspace/babel/babel/messages/catalog.py)

babel/messages/frontend.py:27: ImportError
__________ test_extract_distutils_keyword_arg_388[LW_ QQ Q-expected1] __________

kwarg = 'LW_ QQ Q', expected = ('LW_', 'QQ', 'Q')

    @pytest.mark.parametrize("kwarg,expected", [
        ("LW_", ("LW_",)),
        ("LW_ QQ Q", ("LW_", "QQ", "Q")),
        ("yiy         aia", ("yiy", "aia")),
    ])
    def test_extract_distutils_keyword_arg_388(kwarg, expected):
>       from babel.messages import frontend, setuptools_frontend

tests/messages/test_setuptools_frontend.py:21: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

    """
        babel.messages.frontend
        ~~~~~~~~~~~~~~~~~~~~~~~
    
        Frontends for the message extraction functionality.
    
        :copyright: (c) 2013-2023 by the Babel Team.
        :license: BSD, see LICENSE for more details.
    """
    from __future__ import annotations
    import datetime
    import fnmatch
    import logging
    import optparse
    import os
    import re
    import shutil
    import sys
    import tempfile
    from collections import OrderedDict
    from configparser import RawConfigParser
    from io import StringIO
    from typing import Iterable
    from babel import Locale, localedata
    from babel import __version__ as VERSION
    from babel.core import UnknownLocaleError
>   from babel.messages.catalog import DEFAULT_HEADER, Catalog
E   ImportError: cannot import name 'DEFAULT_HEADER' from 'babel.messages.catalog' (/workspace/babel/babel/messages/catalog.py)

babel/messages/frontend.py:27: ImportError
______ test_extract_distutils_keyword_arg_388[yiy         aia-expected2] _______

kwarg = 'yiy         aia', expected = ('yiy', 'aia')

    @pytest.mark.parametrize("kwarg,expected", [
        ("LW_", ("LW_",)),
        ("LW_ QQ Q", ("LW_", "QQ", "Q")),
        ("yiy         aia", ("yiy", "aia")),
    ])
    def test_extract_distutils_keyword_arg_388(kwarg, expected):
>       from babel.messages import frontend, setuptools_frontend

tests/messages/test_setuptools_frontend.py:21: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

    """
        babel.messages.frontend
        ~~~~~~~~~~~~~~~~~~~~~~~
    
        Frontends for the message extraction functionality.
    
        :copyright: (c) 2013-2023 by the Babel Team.
        :license: BSD, see LICENSE for more details.
    """
    from __future__ import annotations
    import datetime
    import fnmatch
    import logging
    import optparse
    import os
    import re
    import shutil
    import sys
    import tempfile
    from collections import OrderedDict
    from configparser import RawConfigParser
    from io import StringIO
    from typing import Iterable
    from babel import Locale, localedata
    from babel import __version__ as VERSION
    from babel.core import UnknownLocaleError
>   from babel.messages.catalog import DEFAULT_HEADER, Catalog
E   ImportError: cannot import name 'DEFAULT_HEADER' from 'babel.messages.catalog' (/workspace/babel/babel/messages/catalog.py)

babel/messages/frontend.py:27: ImportError
___________________________ test_setuptools_commands ___________________________

tmp_path = PosixPath('/tmp/pytest-of-openhands/pytest-0/test_setuptools_commands0')
monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x77b0dfd2bca0>

    def test_setuptools_commands(tmp_path, monkeypatch):
        """
        Smoke-tests all of the setuptools versions of the commands in turn.
    
        Their full functionality is tested better in `test_frontend.py`.
        """
        # Copy the test project to a temporary directory and work there
        dest = tmp_path / "dest"
        shutil.copytree(data_dir, dest)
        monkeypatch.chdir(dest)
    
        env = os.environ.copy()
        # When in Tox, we need to hack things a bit so as not to have the
        # sub-interpreter `sys.executable` use the tox virtualenv's Babel
        # installation, so the locale data is where we expect it to be.
        if "BABEL_TOX_INI_DIR" in env:
            env["PYTHONPATH"] = env["BABEL_TOX_INI_DIR"]
    
        # Initialize an empty catalog
>       subprocess.check_call([
            sys.executable,
            "setup.py",
            "init_catalog",
            "-i", os.devnull,
            "-l", "fi",
            "-d", "inited",
        ], env=env)

/workspace/babel/tests/messages/test_setuptools_frontend.py:67: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

popenargs = (['/usr/bin/python', 'setup.py', 'init_catalog', '-i', '/dev/null', '-l', ...],)
kwargs = {'env': {'ACP_NODE_DIR': '/opt/acp-node', 'BROWSER_USE_LOGGING_LEVEL': 'warning', 'BROWSER_USE_SETUP_LOGGING': 'false', 'HOME': '/home/openhands', ...}}
retcode = 1
cmd = ['/usr/bin/python', 'setup.py', 'init_catalog', '-i', '/dev/null', '-l', ...]

    def check_call(*popenargs, **kwargs):
        """Run command with arguments.  Wait for command to complete.  If
        the exit code was zero then return, otherwise raise
        CalledProcessError.  The CalledProcessError object will have the
        return code in the returncode attribute.
    
        The arguments are the same as for the call function.  Example:
    
        check_call(["ls", "-l"])
        """
        retcode = call(*popenargs, **kwargs)
        if retcode:
            cmd = kwargs.get("args")
            if cmd is None:
                cmd = popenargs[0]
>           raise CalledProcessError(retcode, cmd)
E           subprocess.CalledProcessError: Command '['/usr/bin/python', 'setup.py', 'init_catalog', '-i', '/dev/null', '-l', 'fi', '-d', 'inited']' returned non-zero exit status 1.

/usr/lib/python3.10/subprocess.py:369: CalledProcessError
----------------------------- Captured stderr call -----------------------------
usage: setup.py [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
   or: setup.py --help [cmd1 cmd2 ...]
   or: setup.py --help-commands
   or: setup.py cmd --help

error: invalid command 'init_catalog'
_____________________ test_format_interval_same_instant_1 ______________________

    def test_format_interval_same_instant_1():
>       assert dates.format_interval(TEST_DT, TEST_DT, "yMMMd", fuzzy=False, locale="fi") == "8. tammik. 2016"
E       AssertionError: assert '2016tammik.8' == '8. tammik. 2016'
E         
E         - 8. tammik. 2016
E         + 2016tammik.8

tests/test_date_intervals.py:12: AssertionError
_____________________ test_format_interval_same_instant_2 ______________________

    def test_format_interval_same_instant_2():
>       assert dates.format_interval(TEST_DT, TEST_DT, "xxx", fuzzy=False, locale="fi") == "8.1.2016 11.46.15"
E       AssertionError: assert '8.1.2016, 11.46' == '8.1.2016 11.46.15'
E         
E         - 8.1.2016 11.46.15
E         ?               ---
E         + 8.1.2016, 11.46
E         ?         +

tests/test_date_intervals.py:16: AssertionError
______________________ test_format_interval_no_difference ______________________

    def test_format_interval_no_difference():
        t1 = TEST_DT
        t2 = t1 + datetime.timedelta(minutes=8)
>       assert dates.format_interval(t1, t2, "yMd", fuzzy=False, locale="fi") == "8.1.2016"
E       AssertionError: assert '8.1.2016–8.1.2016' == '8.1.2016'
E         
E         - 8.1.2016
E         + 8.1.2016–8.1.2016

tests/test_date_intervals.py:30: AssertionError
__________________ test_format_interval_in_tz[pytz.timezone] ___________________

timezone_getter = <function timezone at 0x77b0e0b51cf0>

    def test_format_interval_in_tz(timezone_getter):
        t1 = TEST_DT.replace(tzinfo=UTC)
        t2 = t1 + datetime.timedelta(minutes=18)
        hki_tz = timezone_getter("Europe/Helsinki")
>       assert dates.format_interval(t1, t2, "Hmv", tzinfo=hki_tz, locale="fi") == "13.46\u201314.04 aikavyöhyke: Suomi"
E       AssertionError: assert '8.1.2016–8.1.2016' == '13.46–14.04 ...yöhyke: Suomi'
E         
E         - 13.46–14.04 aikavyöhyke: Suomi
E         + 8.1.2016–8.1.2016

tests/test_date_intervals.py:37: AssertionError
_____________________ test_get_timezone_gmt[pytz.timezone] _____________________

timezone_getter = <function timezone at 0x77b0e0b51cf0>

    def test_get_timezone_gmt(timezone_getter):
        dt = datetime(2007, 4, 1, 15, 30)
>       assert dates.get_timezone_gmt(dt, locale='en') == 'GMT+00:00'

tests/test_dates.py:449: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

datetime = datetime.datetime(2007, 4, 1, 15, 30), width = 'long', locale = 'en'
return_z = False

    def get_timezone_gmt(datetime=None, width='long', locale=LC_TIME, return_z=False):
>       dt=_ensure_datetime_tzinfo(_get_datetime(datetime)); off=dt.utcoffset() or datetime.timedelta(); total=int(off.total_seconds()//60); sign='+' if total>=0 else '-'; total=abs(total); h,m=divmod(total,60)
E       AttributeError: 'datetime.datetime' object has no attribute 'timedelta'

babel/dates.py:1056: AttributeError
_ test_get_timezone_name_tzinfo[pytz.timezone-Europe/Berlin-params2-Mitteleurop\xe4ische Zeit] _

timezone_getter = <function timezone at 0x77b0e0b51cf0>
tzname = 'Europe/Berlin', params = {'locale': 'de_DE'}
expected = 'Mitteleuropäische Zeit'

    @pytest.mark.parametrize(
        "tzname, params, expected",
        [
            ("America/Los_Angeles", {"locale": "en_US"}, "Pacific Time"),
            ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, "PT"),
            ("Europe/Berlin", {"locale": "de_DE"}, "Mitteleurop\xe4ische Zeit"),
            ("Europe/Berlin", {"locale": "pt_BR"}, "Hor\xe1rio da Europa Central"),
            ("America/St_Johns", {"locale": "de_DE"}, "Neufundland-Zeit"),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "generic"},
                "PT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "standard"},
                "PST",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "daylight"},
                "PDT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "generic"},
                "Pacific Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "standard"},
                "Pacific Standard Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "daylight"},
                "Pacific Daylight Time",
            ),
            ("Europe/Berlin", {"locale": "en_US"}, "Central European Time"),
        ],
    )
    def test_get_timezone_name_tzinfo(timezone_getter, tzname, params, expected):
        tz = timezone_getter(tzname)
>       assert dates.get_timezone_name(tz, **params) == expected
E       AssertionError: assert 'Central European Time' == 'Mitteleuropäische Zeit'
E         
E         - Mitteleuropäische Zeit
E         + Central European Time

tests/test_dates.py:521: AssertionError
_ test_get_timezone_name_tzinfo[pytz.timezone-Europe/Berlin-params3-Hor\xe1rio da Europa Central] _

timezone_getter = <function timezone at 0x77b0e0b51cf0>
tzname = 'Europe/Berlin', params = {'locale': 'pt_BR'}
expected = 'Horário da Europa Central'

    @pytest.mark.parametrize(
        "tzname, params, expected",
        [
            ("America/Los_Angeles", {"locale": "en_US"}, "Pacific Time"),
            ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, "PT"),
            ("Europe/Berlin", {"locale": "de_DE"}, "Mitteleurop\xe4ische Zeit"),
            ("Europe/Berlin", {"locale": "pt_BR"}, "Hor\xe1rio da Europa Central"),
            ("America/St_Johns", {"locale": "de_DE"}, "Neufundland-Zeit"),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "generic"},
                "PT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "standard"},
                "PST",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "daylight"},
                "PDT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "generic"},
                "Pacific Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "standard"},
                "Pacific Standard Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "daylight"},
                "Pacific Daylight Time",
            ),
            ("Europe/Berlin", {"locale": "en_US"}, "Central European Time"),
        ],
    )
    def test_get_timezone_name_tzinfo(timezone_getter, tzname, params, expected):
        tz = timezone_getter(tzname)
>       assert dates.get_timezone_name(tz, **params) == expected
E       AssertionError: assert 'Central European Time' == 'Horário da Europa Central'
E         
E         - Horário da Europa Central
E         + Central European Time

tests/test_dates.py:521: AssertionError
_ test_get_timezone_name_tzinfo[pytz.timezone-America/St_Johns-params4-Neufundland-Zeit] _

timezone_getter = <function timezone at 0x77b0e0b51cf0>
tzname = 'America/St_Johns', params = {'locale': 'de_DE'}
expected = 'Neufundland-Zeit'

    @pytest.mark.parametrize(
        "tzname, params, expected",
        [
            ("America/Los_Angeles", {"locale": "en_US"}, "Pacific Time"),
            ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, "PT"),
            ("Europe/Berlin", {"locale": "de_DE"}, "Mitteleurop\xe4ische Zeit"),
            ("Europe/Berlin", {"locale": "pt_BR"}, "Hor\xe1rio da Europa Central"),
            ("America/St_Johns", {"locale": "de_DE"}, "Neufundland-Zeit"),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "generic"},
                "PT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "standard"},
                "PST",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "daylight"},
                "PDT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "generic"},
                "Pacific Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "standard"},
                "Pacific Standard Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "daylight"},
                "Pacific Daylight Time",
            ),
            ("Europe/Berlin", {"locale": "en_US"}, "Central European Time"),
        ],
    )
    def test_get_timezone_name_tzinfo(timezone_getter, tzname, params, expected):
        tz = timezone_getter(tzname)
>       assert dates.get_timezone_name(tz, **params) == expected
E       AssertionError: assert 'Newfoundland Time' == 'Neufundland-Zeit'
E         
E         - Neufundland-Zeit
E         + Newfoundland Time

tests/test_dates.py:521: AssertionError
_ test_get_timezone_name_time_pytz[America/Los_Angeles-params0-Pacific Standard Time-pytz.timezone] _

timezone_getter = <function timezone at 0x77b0e0b51cf0>
tzname = 'America/Los_Angeles', params = {'locale': 'en_US'}
expected = 'Pacific Standard Time'

    @pytest.mark.parametrize("timezone_getter", ["pytz.timezone"], indirect=True)
    @pytest.mark.parametrize(
        "tzname, params, expected",
        [
            ("America/Los_Angeles", {"locale": "en_US"}, "Pacific Standard Time"),
            (
                "America/Los_Angeles",
                {"locale": "en_US", "return_zone": True},
                "America/Los_Angeles",
            ),
            ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, "PST"),
        ],
    )
    def test_get_timezone_name_time_pytz(timezone_getter, tzname, params, expected):
        """pytz (by design) can't determine if the time is in DST or not,
        so it will always return Standard time"""
        dt = time(15, 30, tzinfo=timezone_getter(tzname))
>       assert dates.get_timezone_name(dt, **params) == expected
E       AssertionError: assert 'Pacific Time' == 'Pacific Standard Time'
E         
E         - Pacific Standard Time
E         + Pacific Time

tests/test_dates.py:541: AssertionError
_ test_get_timezone_name_time_pytz[America/Los_Angeles-params2-PST-pytz.timezone] _

timezone_getter = <function timezone at 0x77b0e0b51cf0>
tzname = 'America/Los_Angeles', params = {'locale': 'en_US', 'width': 'short'}
expected = 'PST'

    @pytest.mark.parametrize("timezone_getter", ["pytz.timezone"], indirect=True)
    @pytest.mark.parametrize(
        "tzname, params, expected",
        [
            ("America/Los_Angeles", {"locale": "en_US"}, "Pacific Standard Time"),
            (
                "America/Los_Angeles",
                {"locale": "en_US", "return_zone": True},
                "America/Los_Angeles",
            ),
            ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, "PST"),
        ],
    )
    def test_get_timezone_name_time_pytz(timezone_getter, tzname, params, expected):
        """pytz (by design) can't determine if the time is in DST or not,
        so it will always return Standard time"""
        dt = time(15, 30, tzinfo=timezone_getter(tzname))
>       assert dates.get_timezone_name(dt, **params) == expected
E       AssertionError: assert 'PT' == 'PST'
E         
E         - PST
E         ?  -
E         + PT

tests/test_dates.py:541: AssertionError
_____________________ test_format_datetime[pytz.timezone] ______________________

timezone_getter = <function timezone at 0x77b0e0b51cf0>

    def test_format_datetime(timezone_getter):
        dt = datetime(2007, 4, 1, 15, 30)
>       assert (dates.format_datetime(dt, locale='en_US') ==
                'Apr 1, 2007, 3:30:00\u202fPM')
E       AssertionError: assert 'Apr 1, 2007,...202fafternoon' == 'Apr 1, 2007, 3:30:00\u202fPM'
E         
E         - Apr 1, 2007, 3:30:00 PM
E         ?                      ^^
E         + Apr 1, 2007, 3:30:00 afternoon
E         ?                      ^^^^^^^^^

tests/test_dates.py:566: AssertionError
_______________________ test_format_time[pytz.timezone] ________________________

timezone_getter = <function timezone at 0x77b0e0b51cf0>

    def test_format_time(timezone_getter):
        t = time(15, 30)
>       assert dates.format_time(t, locale='en_US') == '3:30:00\u202fPM'
E       AssertionError: assert '3:30:00\u202fafternoon' == '3:30:00\u202fPM'
E         
E         - 3:30:00 PM
E         + 3:30:00 afternoon

tests/test_dates.py:588: AssertionError
_____________________ test_format_skeleton[pytz.timezone] ______________________

timezone_getter = <function timezone at 0x77b0e0b51cf0>

    def test_format_skeleton(timezone_getter):
        dt = datetime(2007, 4, 1, 15, 30)
        assert (dates.format_skeleton('yMEd', dt, locale='en_US') == 'Sun, 4/1/2007')
>       assert (dates.format_skeleton('yMEd', dt, locale='th') == 'อา. 1/4/2007')
E       AssertionError: assert 'อา., 4/1/2007' == 'อา. 1/4/2007'
E         
E         - อา. 1/4/2007
E         + อา., 4/1/2007

tests/test_dates.py:616: AssertionError
______________ test_no_inherit_metazone_formatting[pytz.timezone] ______________

timezone_getter = <function timezone at 0x77b0e0b51cf0>

    def test_no_inherit_metazone_formatting(timezone_getter):
        # See: https://github.com/python-babel/babel/issues/428
        tz = timezone_getter('America/Los_Angeles')
        t = _localize(tz, datetime(2016, 1, 6, 7))
>       assert dates.format_time(t, format='long', locale='en_US') == "7:00:00\u202fAM PST"
E       AssertionError: assert '7:00:00\u202fmorning PST' == '7:00:00\u202fAM PST'
E         
E         - 7:00:00 AM PST
E         + 7:00:00 morning PST

tests/test_dates.py:724: AssertionError
________________ TestFormat.test_format_datetime[pytz.timezone] ________________

self = <tests.test_support.TestFormat object at 0x77b0dfdd1900>
timezone_getter = <function timezone at 0x77b0e0b51cf0>

    def test_format_datetime(self, timezone_getter):
        when = datetime.datetime(2007, 4, 1, 15, 30)
        fmt = support.Format('en_US', tzinfo=timezone_getter('US/Eastern'))
>       assert fmt.datetime(when) == 'Apr 1, 2007, 11:30:00\u202fAM'
E       AssertionError: assert 'Apr 1, 2007,...\u202fmorning' == 'Apr 1, 2007,...30:00\u202fAM'
E         
E         - Apr 1, 2007, 11:30:00 AM
E         ?                       ^^
E         + Apr 1, 2007, 11:30:00 morning
E         ?                       ^^^^^^^

tests/test_support.py:304: AssertionError
__________________ TestFormat.test_format_time[pytz.timezone] __________________

self = <tests.test_support.TestFormat object at 0x77b0dfdd1de0>
timezone_getter = <function timezone at 0x77b0e0b51cf0>

    def test_format_time(self, timezone_getter):
        when = datetime.datetime(2007, 4, 1, 15, 30)
        fmt = support.Format('en_US', tzinfo=timezone_getter('US/Eastern'))
>       assert fmt.time(when) == '11:30:00\u202fAM'
E       AssertionError: assert '11:30:00\u202fmorning' == '11:30:00\u202fAM'
E         
E         - 11:30:00 AM
E         + 11:30:00 morning

tests/test_support.py:309: AssertionError
________________ test_format_interval_in_tz[zoneinfo.ZoneInfo] _________________

timezone_getter = <class 'zoneinfo.ZoneInfo'>

    def test_format_interval_in_tz(timezone_getter):
        t1 = TEST_DT.replace(tzinfo=UTC)
        t2 = t1 + datetime.timedelta(minutes=18)
        hki_tz = timezone_getter("Europe/Helsinki")
>       assert dates.format_interval(t1, t2, "Hmv", tzinfo=hki_tz, locale="fi") == "13.46\u201314.04 aikavyöhyke: Suomi"
E       AssertionError: assert '8.1.2016–8.1.2016' == '13.46–14.04 ...yöhyke: Suomi'
E         
E         - 13.46–14.04 aikavyöhyke: Suomi
E         + 8.1.2016–8.1.2016

tests/test_date_intervals.py:37: AssertionError
___________________ test_get_timezone_gmt[zoneinfo.ZoneInfo] ___________________

timezone_getter = <class 'zoneinfo.ZoneInfo'>

    def test_get_timezone_gmt(timezone_getter):
        dt = datetime(2007, 4, 1, 15, 30)
>       assert dates.get_timezone_gmt(dt, locale='en') == 'GMT+00:00'

tests/test_dates.py:449: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

datetime = datetime.datetime(2007, 4, 1, 15, 30), width = 'long', locale = 'en'
return_z = False

    def get_timezone_gmt(datetime=None, width='long', locale=LC_TIME, return_z=False):
>       dt=_ensure_datetime_tzinfo(_get_datetime(datetime)); off=dt.utcoffset() or datetime.timedelta(); total=int(off.total_seconds()//60); sign='+' if total>=0 else '-'; total=abs(total); h,m=divmod(total,60)
E       AttributeError: 'datetime.datetime' object has no attribute 'timedelta'

babel/dates.py:1056: AttributeError
_ test_get_timezone_name_tzinfo[zoneinfo.ZoneInfo-Europe/Berlin-params2-Mitteleurop\xe4ische Zeit] _

timezone_getter = <class 'zoneinfo.ZoneInfo'>, tzname = 'Europe/Berlin'
params = {'locale': 'de_DE'}, expected = 'Mitteleuropäische Zeit'

    @pytest.mark.parametrize(
        "tzname, params, expected",
        [
            ("America/Los_Angeles", {"locale": "en_US"}, "Pacific Time"),
            ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, "PT"),
            ("Europe/Berlin", {"locale": "de_DE"}, "Mitteleurop\xe4ische Zeit"),
            ("Europe/Berlin", {"locale": "pt_BR"}, "Hor\xe1rio da Europa Central"),
            ("America/St_Johns", {"locale": "de_DE"}, "Neufundland-Zeit"),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "generic"},
                "PT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "standard"},
                "PST",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "daylight"},
                "PDT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "generic"},
                "Pacific Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "standard"},
                "Pacific Standard Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "daylight"},
                "Pacific Daylight Time",
            ),
            ("Europe/Berlin", {"locale": "en_US"}, "Central European Time"),
        ],
    )
    def test_get_timezone_name_tzinfo(timezone_getter, tzname, params, expected):
        tz = timezone_getter(tzname)
>       assert dates.get_timezone_name(tz, **params) == expected
E       AssertionError: assert 'Central European Time' == 'Mitteleuropäische Zeit'
E         
E         - Mitteleuropäische Zeit
E         + Central European Time

tests/test_dates.py:521: AssertionError
_ test_get_timezone_name_tzinfo[zoneinfo.ZoneInfo-Europe/Berlin-params3-Hor\xe1rio da Europa Central] _

timezone_getter = <class 'zoneinfo.ZoneInfo'>, tzname = 'Europe/Berlin'
params = {'locale': 'pt_BR'}, expected = 'Horário da Europa Central'

    @pytest.mark.parametrize(
        "tzname, params, expected",
        [
            ("America/Los_Angeles", {"locale": "en_US"}, "Pacific Time"),
            ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, "PT"),
            ("Europe/Berlin", {"locale": "de_DE"}, "Mitteleurop\xe4ische Zeit"),
            ("Europe/Berlin", {"locale": "pt_BR"}, "Hor\xe1rio da Europa Central"),
            ("America/St_Johns", {"locale": "de_DE"}, "Neufundland-Zeit"),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "generic"},
                "PT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "standard"},
                "PST",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "daylight"},
                "PDT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "generic"},
                "Pacific Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "standard"},
                "Pacific Standard Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "daylight"},
                "Pacific Daylight Time",
            ),
            ("Europe/Berlin", {"locale": "en_US"}, "Central European Time"),
        ],
    )
    def test_get_timezone_name_tzinfo(timezone_getter, tzname, params, expected):
        tz = timezone_getter(tzname)
>       assert dates.get_timezone_name(tz, **params) == expected
E       AssertionError: assert 'Central European Time' == 'Horário da Europa Central'
E         
E         - Horário da Europa Central
E         + Central European Time

tests/test_dates.py:521: AssertionError
_ test_get_timezone_name_tzinfo[zoneinfo.ZoneInfo-America/St_Johns-params4-Neufundland-Zeit] _

timezone_getter = <class 'zoneinfo.ZoneInfo'>, tzname = 'America/St_Johns'
params = {'locale': 'de_DE'}, expected = 'Neufundland-Zeit'

    @pytest.mark.parametrize(
        "tzname, params, expected",
        [
            ("America/Los_Angeles", {"locale": "en_US"}, "Pacific Time"),
            ("America/Los_Angeles", {"width": "short", "locale": "en_US"}, "PT"),
            ("Europe/Berlin", {"locale": "de_DE"}, "Mitteleurop\xe4ische Zeit"),
            ("Europe/Berlin", {"locale": "pt_BR"}, "Hor\xe1rio da Europa Central"),
            ("America/St_Johns", {"locale": "de_DE"}, "Neufundland-Zeit"),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "generic"},
                "PT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "standard"},
                "PST",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "short", "zone_variant": "daylight"},
                "PDT",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "generic"},
                "Pacific Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "standard"},
                "Pacific Standard Time",
            ),
            (
                "America/Los_Angeles",
                {"locale": "en", "width": "long", "zone_variant": "daylight"},
                "Pacific Daylight Time",
            ),
            ("Europe/Berlin", {"locale": "en_US"}, "Central European Time"),
        ],
    )
    def test_get_timezone_name_tzinfo(timezone_getter, tzname, params, expected):
        tz = timezone_getter(tzname)
>       assert dates.get_timezone_name(tz, **params) == expected
E       AssertionError: assert 'Newfoundland Time' == 'Neufundland-Zeit'
E         
E         - Neufundland-Zeit
E         + Newfoundland Time

tests/test_dates.py:521: AssertionError
___________________ test_format_datetime[zoneinfo.ZoneInfo] ____________________

timezone_getter = <class 'zoneinfo.ZoneInfo'>

    def test_format_datetime(timezone_getter):
        dt = datetime(2007, 4, 1, 15, 30)
>       assert (dates.format_datetime(dt, locale='en_US') ==
                'Apr 1, 2007, 3:30:00\u202fPM')
E       AssertionError: assert 'Apr 1, 2007,...202fafternoon' == 'Apr 1, 2007, 3:30:00\u202fPM'
E         
E         - Apr 1, 2007, 3:30:00 PM
E         ?                      ^^
E         + Apr 1, 2007, 3:30:00 afternoon
E         ?                      ^^^^^^^^^

tests/test_dates.py:566: AssertionError
_____________________ test_format_time[zoneinfo.ZoneInfo] ______________________

timezone_getter = <class 'zoneinfo.ZoneInfo'>

    def test_format_time(timezone_getter):
        t = time(15, 30)
>       assert dates.format_time(t, locale='en_US') == '3:30:00\u202fPM'
E       AssertionError: assert '3:30:00\u202fafternoon' == '3:30:00\u202fPM'
E         
E         - 3:30:00 PM
E         + 3:30:00 afternoon

tests/test_dates.py:588: AssertionError
___________________ test_format_skeleton[zoneinfo.ZoneInfo] ____________________

timezone_getter = <class 'zoneinfo.ZoneInfo'>

    def test_format_skeleton(timezone_getter):
        dt = datetime(2007, 4, 1, 15, 30)
        assert (dates.format_skeleton('yMEd', dt, locale='en_US') == 'Sun, 4/1/2007')
>       assert (dates.format_skeleton('yMEd', dt, locale='th') == 'อา. 1/4/2007')
E       AssertionError: assert 'อา., 4/1/2007' == 'อา. 1/4/2007'
E         
E         - อา. 1/4/2007
E         + อา., 4/1/2007

tests/test_dates.py:616: AssertionError
____________ test_no_inherit_metazone_formatting[zoneinfo.ZoneInfo] ____________

timezone_getter = <class 'zoneinfo.ZoneInfo'>

    def test_no_inherit_metazone_formatting(timezone_getter):
        # See: https://github.com/python-babel/babel/issues/428
        tz = timezone_getter('America/Los_Angeles')
        t = _localize(tz, datetime(2016, 1, 6, 7))
>       assert dates.format_time(t, format='long', locale='en_US') == "7:00:00\u202fAM PST"
E       AssertionError: assert '7:00:00\u202fmorning PDT' == '7:00:00\u202fAM PST'
E         
E         - 7:00:00 AM PST
E         + 7:00:00 morning PDT

tests/test_dates.py:724: AssertionError
______________ TestFormat.test_format_datetime[zoneinfo.ZoneInfo] ______________

self = <tests.test_support.TestFormat object at 0x77b0dfdd19f0>
timezone_getter = <class 'zoneinfo.ZoneInfo'>

    def test_format_datetime(self, timezone_getter):
        when = datetime.datetime(2007, 4, 1, 15, 30)
        fmt = support.Format('en_US', tzinfo=timezone_getter('US/Eastern'))
>       assert fmt.datetime(when) == 'Apr 1, 2007, 11:30:00\u202fAM'
E       AssertionError: assert 'Apr 1, 2007,...\u202fmorning' == 'Apr 1, 2007,...30:00\u202fAM'
E         
E         - Apr 1, 2007, 11:30:00 AM
E         ?                       ^^
E         + Apr 1, 2007, 11:30:00 morning
E         ?                       ^^^^^^^

tests/test_support.py:304: AssertionError
________________ TestFormat.test_format_time[zoneinfo.ZoneInfo] ________________

self = <tests.test_support.TestFormat object at 0x77b0dfdd1ed0>
timezone_getter = <class 'zoneinfo.ZoneInfo'>

    def test_format_time(self, timezone_getter):
        when = datetime.datetime(2007, 4, 1, 15, 30)
        fmt = support.Format('en_US', tzinfo=timezone_getter('US/Eastern'))
>       assert fmt.time(when) == '11:30:00\u202fAM'
E       AssertionError: assert '11:30:00\u202fmorning' == '11:30:00\u202fAM'
E         
E         - 11:30:00 AM
E         + 11:30:00 morning

tests/test_support.py:309: AssertionError
_________________________ test_format_interval_12_hour _________________________

    def test_format_interval_12_hour():
        t2 = TEST_DT
        t1 = t2 - datetime.timedelta(hours=1)
>       assert dates.format_interval(t1, t2, "hm", locale="en") == "10:46\u2009\u2013\u200911:46\u202fAM"
E       AssertionError: assert '1/8/16\u2009–\u20091/8/16' == '10:46\u2009–...11:46\u202fAM'
E         
E         - 10:46 – 11:46 AM
E         + 1/8/16 – 1/8/16

tests/test_date_intervals.py:43: AssertionError
______________________________ test_get_era_names ______________________________

    def test_get_era_names():
        assert dates.get_era_names('wide', locale='en_US')[1] == 'Anno Domini'
>       assert dates.get_era_names('abbreviated', locale='de_DE')[1] == 'n. Chr.'
E       AssertionError: assert 'AD' == 'n. Chr.'
E         
E         - n. Chr.
E         + AD

tests/test_dates.py:427: AssertionError
____________________________ test_format_timedelta _____________________________

    def test_format_timedelta():
        assert (dates.format_timedelta(timedelta(weeks=12), locale='en_US')
                == '3 months')
        assert (dates.format_timedelta(timedelta(seconds=1), locale='es')
                == '1 segundo')
    
>       assert (dates.format_timedelta(timedelta(hours=3), granularity='day',
                                       locale='en_US')
                == '1 day')
E       AssertionError: assert '0 days' == '1 day'
E         
E         - 1 day
E         + 0 days

tests/test_dates.py:628: AssertionError
_____________________ test_datetime_format_get_week_number _____________________

    def test_datetime_format_get_week_number():
        format = dates.DateTimeFormat(date(2006, 1, 8), Locale.parse('de_DE'))
>       assert format.get_week_number(6) == 1
E       assert 2 == 1
E        +  where 2 = get_week_number(6)
E        +    where get_week_number = <babel.dates.DateTimeFormat object at 0x77b0df7dd6c0>.get_week_number

tests/test_dates.py:678: AssertionError
______________________________ test_zh_TW_format _______________________________

    def test_zh_TW_format():
        # Refs GitHub issue #378
>       assert dates.format_time(datetime(2016, 4, 8, 12, 34, 56), locale='zh_TW') == '中午12:34:56'
E       AssertionError: assert '12:34:56\u202fPM' == '中午12:34:56'
E         
E         - 中午12:34:56
E         ? --
E         + 12:34:56 PM
E         ?         +++

tests/test_dates.py:702: AssertionError
____________________________ test_smoke_units[agq] _____________________________

locale = Locale('agq')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('agq'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[am] _____________________________

locale = Locale('am')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('am'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[ar] _____________________________

locale = Locale('ar')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ar'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[ar_EG] ____________________________

locale = Locale('ar', territory='EG')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ar', territory='EG'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[ar_IL] ____________________________

locale = Locale('ar', territory='IL')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ar', territory='IL'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_______________________ test_smoke_units[ca_ES_VALENCIA] _______________________

locale = Locale('ca', territory='ES', variant='VALENCIA')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ca', territory='ES', variant='VALENCIA'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[de] _____________________________

locale = Locale('de')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('de'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[de_AT] ____________________________

locale = Locale('de', territory='AT')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('de', territory='AT'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[de_DE] ____________________________

locale = Locale('de', territory='DE')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('de', territory='DE'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[ee] _____________________________

locale = Locale('ee')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ee'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[el_GR] ____________________________

locale = Locale('el', territory='GR')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('el', territory='GR'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[en] _____________________________

locale = Locale('en')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('en'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[en_150] ___________________________

locale = Locale('en', territory='150')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('en', territory='150'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[en_GB] ____________________________

locale = Locale('en', territory='GB')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('en', territory='GB'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[en_US] ____________________________

locale = Locale('en', territory='US')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('en', territory='US'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
________________________ test_smoke_units[en_US_POSIX] _________________________

locale = Locale('en', territory='US', variant='POSIX')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('en', territory='US', variant='POSIX'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[es] _____________________________

locale = Locale('es')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('es'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[es_419] ___________________________

locale = Locale('es', territory='419')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('es', territory='419'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[es_AR] ____________________________

locale = Locale('es', territory='AR')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('es', territory='AR'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[es_CO] ____________________________

locale = Locale('es', territory='CO')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('es', territory='CO'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[es_ES] ____________________________

locale = Locale('es', territory='ES')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('es', territory='ES'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[es_GT] ____________________________

locale = Locale('es', territory='GT')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('es', territory='GT'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[es_US] ____________________________

locale = Locale('es', territory='US')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('es', territory='US'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[fi] _____________________________

locale = Locale('fi')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('fi'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[fi_FI] ____________________________

locale = Locale('fi', territory='FI')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('fi', territory='FI'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[fr] _____________________________

locale = Locale('fr')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('fr'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[fr_CA] ____________________________

locale = Locale('fr', territory='CA')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('fr', territory='CA'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[fr_FR] ____________________________

locale = Locale('fr', territory='FR')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('fr', territory='FR'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[gv] _____________________________

locale = Locale('gv')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('gv'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[ii] _____________________________

locale = Locale('ii')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ii'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[it] _____________________________

locale = Locale('it')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('it'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[ja] _____________________________

locale = Locale('ja')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ja'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[ja_JP] ____________________________

locale = Locale('ja', territory='JP')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ja', territory='JP'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[kw_GB] ____________________________

locale = Locale('kw', territory='GB')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('kw', territory='GB'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[lt_LT] ____________________________

locale = Locale('lt', territory='LT')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('lt', territory='LT'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[mk] _____________________________

locale = Locale('mk')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('mk'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[nb] _____________________________

locale = Locale('nb')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('nb'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[ne] _____________________________

locale = Locale('ne')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ne'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[nl_NL] ____________________________

locale = Locale('nl', territory='NL')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('nl', territory='NL'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
__________________________ test_smoke_units[pa_Arab] ___________________________

locale = Locale('pa', script='Arab')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('pa', script='Arab'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[pl] _____________________________

locale = Locale('pl')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('pl'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[pt] _____________________________

locale = Locale('pt')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('pt'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[pt_BR] ____________________________

locale = Locale('pt', territory='BR')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('pt', territory='BR'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[ro] _____________________________

locale = Locale('ro')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ro'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
____________________________ test_smoke_units[root] ____________________________

locale = Locale('root')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('root'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[ru] _____________________________

locale = Locale('ru')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ru'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[ru_RU] ____________________________

locale = Locale('ru', territory='RU')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('ru', territory='RU'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[sv] _____________________________

locale = Locale('sv')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('sv'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
___________________________ test_smoke_units[sv_SE] ____________________________

locale = Locale('sv', territory='SE')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('sv', territory='SE'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[sw] _____________________________

locale = Locale('sw')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('sw'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[th] _____________________________

locale = Locale('th')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('th'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
____________________________ test_smoke_units[yav] _____________________________

locale = Locale('yav')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('yav'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_____________________________ test_smoke_units[zh] _____________________________

locale = Locale('zh')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('zh'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_________________________ test_smoke_units[zh_Hans_CN] _________________________

locale = Locale('zh', territory='CN', script='Hans')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('zh', territory='CN', script='Hans'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_________________________ test_smoke_units[zh_Hans_SG] _________________________

locale = Locale('zh', territory='SG', script='Hans')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('zh', territory='SG', script='Hans'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
__________________________ test_smoke_units[zh_Hant] ___________________________

locale = Locale('zh', script='Hant')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('zh', script='Hant'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
_________________________ test_smoke_units[zh_Hant_TW] _________________________

locale = Locale('zh', territory='TW', script='Hant')

    @pytest.mark.all_locales
    def test_smoke_units(locale):
        locale = Locale.parse(locale)
        for unit in ('length-meter', 'mass-kilogram', 'energy-calorie', 'volume-liter'):
            for number in NUMBERS:
>               assert units.format_unit(number, measurement_unit=unit, locale=locale)
E               AssertionError: assert None
E                +  where None = <function format_unit at 0x77b0dfeee200>(Decimal('-33.76'), measurement_unit='length-meter', locale=Locale('zh', territory='TW', script='Hant'))
E                +    where <function format_unit at 0x77b0dfeee200> = units.format_unit

tests/test_smoke.py:60: AssertionError
__________________ LazyProxyTestCase.test_can_deepcopy_proxy ___________________

self = <tests.test_support.LazyProxyTestCase testMethod=test_can_deepcopy_proxy>

    def test_can_deepcopy_proxy(self):
        from copy import deepcopy
        numbers = [1, 2]
    
        def first(xs):
            return xs[0]
    
        proxy = support.LazyProxy(first, numbers)
        proxy_deepcopy = deepcopy(proxy)
    
        numbers.pop(0)
        assert proxy.value == 2
>       assert proxy_deepcopy.value == 1
E       assert 2 == 1
E        +  where 2 = 2.value

tests/test_support.py:286: AssertionError
________________ LazyProxyTestCase.test_handle_attribute_error _________________

self = <tests.test_support.LazyProxyTestCase testMethod=test_handle_attribute_error>

    def test_handle_attribute_error(self):
    
        def raise_attribute_error():
            raise AttributeError('message')
    
        proxy = support.LazyProxy(raise_attribute_error)
        with pytest.raises(AttributeError) as exception:
>           _ = proxy.value

tests/test_support.py:295: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
babel/support.py:561: in __getattr__
    def __getattr__(self, name): return getattr(self.value, name)
babel/support.py:561: in __getattr__
    def __getattr__(self, name): return getattr(self.value, name)
E   RecursionError: maximum recursion depth exceeded while calling a Python object
!!! Recursion detected (same locals & position)
________________________ TestFormat.test_format_number _________________________

self = <tests.test_support.TestFormat object at 0x77b0dfdd2290>

    def test_format_number(self):
        assert support.Format('en_US').number(1234) == '1,234'
>       assert support.Format('ar_EG', numbering_system="default").number(1234) == '1٬234'
E       TypeError: Format.__init__() got an unexpected keyword argument 'numbering_system'

tests/test_support.py:313: TypeError
________________________ TestFormat.test_format_decimal ________________________

self = <tests.test_support.TestFormat object at 0x77b0dfd3cac0>

    def test_format_decimal(self):
        assert support.Format('en_US').decimal(1234.5) == '1,234.5'
        assert support.Format('en_US').decimal(Decimal("1234.5")) == '1,234.5'
>       assert support.Format('ar_EG', numbering_system="default").decimal(1234.5) == '1٬234٫5'
E       TypeError: Format.__init__() got an unexpected keyword argument 'numbering_system'

tests/test_support.py:318: TypeError
____________________ TestFormat.test_format_compact_decimal ____________________

self = <tests.test_support.TestFormat object at 0x77b0dfd3d4b0>

    def test_format_compact_decimal(self):
        assert support.Format('en_US').compact_decimal(1234) == '1K'
>       assert support.Format('ar_EG', numbering_system="default").compact_decimal(
            1234, fraction_digits=1) == '1٫2\xa0ألف'
E       TypeError: Format.__init__() got an unexpected keyword argument 'numbering_system'

tests/test_support.py:323: TypeError
_______________________ TestFormat.test_format_currency ________________________

self = <tests.test_support.TestFormat object at 0x77b0dfdd21a0>

    def test_format_currency(self):
        assert support.Format('en_US').currency(1099.98, 'USD') == '$1,099.98'
        assert support.Format('en_US').currency(Decimal("1099.98"), 'USD') == '$1,099.98'
>       assert support.Format('ar_EG', numbering_system="default").currency(
            1099.98, 'EGP') == '\u200f1٬099٫98\xa0ج.م.\u200f'
E       TypeError: Format.__init__() got an unexpected keyword argument 'numbering_system'

tests/test_support.py:331: TypeError
___________________ TestFormat.test_format_compact_currency ____________________

self = <tests.test_support.TestFormat object at 0x77b0dfdd17b0>

    def test_format_compact_currency(self):
        assert support.Format('en_US').compact_currency(1099.98, 'USD') == '$1K'
        assert support.Format('en_US').compact_currency(Decimal("1099.98"), 'USD') == '$1K'
>       assert support.Format('ar_EG', numbering_system="default").compact_currency(
            1099.98, 'EGP') == '1\xa0ألف\xa0ج.م.\u200f'
E       TypeError: Format.__init__() got an unexpected keyword argument 'numbering_system'

tests/test_support.py:337: TypeError
________________________ TestFormat.test_format_percent ________________________

self = <tests.test_support.TestFormat object at 0x77b0dfdd1390>

    def test_format_percent(self):
        assert support.Format('en_US').percent(0.34) == '34%'
        assert support.Format('en_US').percent(Decimal("0.34")) == '34%'
>       assert support.Format('ar_EG', numbering_system="default").percent(134.5) == '13٬450%'
E       TypeError: Format.__init__() got an unexpected keyword argument 'numbering_system'

tests/test_support.py:343: TypeError
______________________ TestFormat.test_format_scientific _______________________

self = <tests.test_support.TestFormat object at 0x77b0dfdd0f10>

    def test_format_scientific(self):
        assert support.Format('en_US').scientific(10000) == '1E4'
        assert support.Format('en_US').scientific(Decimal("10000")) == '1E4'
>       assert support.Format('ar_EG', numbering_system="default").scientific(10000) == '1اس4'
E       TypeError: Format.__init__() got an unexpected keyword argument 'numbering_system'

tests/test_support.py:348: TypeError
_______________________________ test_lazy_proxy ________________________________

    def test_lazy_proxy():
        def greeting(name='world'):
            return f"Hello, {name}!"
    
        lazy_greeting = support.LazyProxy(greeting, name='Joe')
        assert str(lazy_greeting) == "Hello, Joe!"
>       assert '  ' + lazy_greeting == '  Hello, Joe!'
E       TypeError: can only concatenate str (not "LazyProxy") to str

tests/test_support.py:357: TypeError
___________________________ test_catalog_merge_files ___________________________

    def test_catalog_merge_files():
        # Refs issues #92, #162
        t1 = support.Translations()
        assert t1.files == []
        t1._catalog["foo"] = "bar"
        fp = BytesIO()
        write_mo(fp, Catalog())
        fp.seek(0)
        fp.name = "pro.mo"
        t2 = support.Translations(fp)
>       assert t2.files == ["pro.mo"]
E       AssertionError: assert [] == ['pro.mo']
E         
E         Right contains one more item: 'pro.mo'
E         Use -v to get more diff

tests/test_support.py:383: AssertionError
--------------------------------- JSON report ----------------------------------
report saved to: report.json
=========================== short test summary info ============================
FAILED tests/messages/test_catalog.py::MessageTestCase::test_python_format - ...
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_fuzzy_matching_regarding_plurals
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_mime_headers_contain_same_information_as_attributes
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_stores_datetime_correctly
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_two_messages_with_same_singular
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_fuzzy_matching_long_string
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_fuzzy_matching_no_cascading
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_fuzzy_matching_no_msgstr
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_fuzzy_matching_with_case_change
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_fuzzy_matching_with_changed_context
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_fuzzy_matching_with_char_change
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_fuzzy_matching_with_new_context
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_message_changed_to_plural
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_message_changed_to_simple
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_message_updates_comments
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_no_template_mutation
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_po_ignores_pot_creation_date
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_po_keeps_po_revision_date
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_po_updates_pot_creation_date
FAILED tests/messages/test_catalog.py::CatalogTestCase::test_update_without_fuzzy_matching
FAILED tests/messages/test_catalog.py::test_message_pluralizable - AttributeE...
FAILED tests/messages/test_catalog.py::test_message_python_format - Attribute...
FAILED tests/messages/test_catalog.py::test_catalog - AssertionError: assert ...
FAILED tests/messages/test_catalog.py::test_catalog_mime_headers - AttributeE...
FAILED tests/messages/test_catalog.py::test_catalog_mime_headers_set_locale
FAILED tests/messages/test_catalog.py::test_catalog_num_plurals - AssertionEr...
FAILED tests/messages/test_catalog.py::test_catalog_plural_expr - AssertionEr...
FAILED tests/messages/test_catalog.py::test_catalog_plural_forms - AttributeE...
FAILED tests/messages/test_catalog.py::test_catalog_setitem - TypeError: 'Cat...
FAILED tests/messages/test_catalog.py::test_catalog_update - assert 4 == 3
FAILED tests/messages/test_catalog.py::test_datetime_parsing - AttributeError...
FAILED tests/messages/test_catalog.py::test_update_catalog_comments - TypeErr...
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_comment_tag
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_comment_tag_multiline
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_comment_tag_with_leading_space
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_comment_tags_not_on_start_of_comment
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_comments_with_calls_that_spawn_multiple_lines
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_concatenated_strings
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_declarations
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_different_signatures
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_extract_default_encoding_ascii
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_extract_default_encoding_utf8
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_extract_strip_comment_tags
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_invalid_translator_comments
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_invalid_translator_comments2
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_invalid_translator_comments3
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_multiline
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_multiline_strings
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_multiple_comment_tags
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_nested_calls
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_nested_comments
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_nested_messages
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_npgettext
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_translator_comments_with_previous_non_translator_comments
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_triple_quoted_strings
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_two_succeeding_comments
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_unicode_string_arg
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_utf8_bom_with_latin_magic_comment_fails
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_utf8_message
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_utf8_message_with_magic_comment
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_utf8_message_with_utf8_bom
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_utf8_message_with_utf8_bom_and_magic_comment
FAILED tests/messages/test_extract.py::ExtractPythonTestCase::test_utf8_raw_strings_match_unicode_strings
FAILED tests/messages/test_extract.py::ExtractTestCase::test_different_signatures
FAILED tests/messages/test_extract.py::ExtractTestCase::test_empty_string_msgid
FAILED tests/messages/test_extract.py::ExtractTestCase::test_extract_allows_callable
FAILED tests/messages/test_extract.py::ExtractTestCase::test_f_strings - Type...
FAILED tests/messages/test_extract.py::ExtractTestCase::test_f_strings_non_utf8
FAILED tests/messages/test_extract.py::ExtractTestCase::test_future - TypeErr...
FAILED tests/messages/test_extract.py::ExtractTestCase::test_invalid_extract_method
FAILED tests/messages/test_extract.py::ExtractTestCase::test_invalid_filter
FAILED tests/messages/test_extract.py::ExtractTestCase::test_warn_if_empty_string_msgid_found_in_context_aware_extraction_method
FAILED tests/messages/test_js_extract.py::test_simple_extract - TypeError: 'N...
FAILED tests/messages/test_js_extract.py::test_various_calls - TypeError: 'No...
FAILED tests/messages/test_js_extract.py::test_message_with_line_comment - Ty...
FAILED tests/messages/test_js_extract.py::test_message_with_multiline_comment
FAILED tests/messages/test_js_extract.py::test_ignore_function_definitions - ...
FAILED tests/messages/test_js_extract.py::test_misplaced_comments - TypeError...
FAILED tests/messages/test_js_extract.py::test_jsx_extraction[False] - TypeEr...
FAILED tests/messages/test_js_extract.py::test_jsx_extraction[True] - TypeErr...
FAILED tests/messages/test_js_extract.py::test_dotted_keyword_extract - TypeE...
FAILED tests/messages/test_js_extract.py::test_template_string_standard_usage
FAILED tests/messages/test_js_extract.py::test_template_string_tag_usage - Ty...
FAILED tests/messages/test_js_extract.py::test_inside_template_string - TypeE...
FAILED tests/messages/test_js_extract.py::test_inside_template_string_with_linebreaks
FAILED tests/messages/test_js_extract.py::test_inside_nested_template_string
FAILED tests/messages/test_jslexer.py::test_unquote - assert None == ''
FAILED tests/messages/test_jslexer.py::test_dollar_in_identifier - TypeError:...
FAILED tests/messages/test_jslexer.py::test_dotted_name - TypeError: 'NoneTyp...
FAILED tests/messages/test_jslexer.py::test_dotted_name_end - TypeError: 'Non...
FAILED tests/messages/test_jslexer.py::test_template_string - TypeError: 'Non...
FAILED tests/messages/test_jslexer.py::test_jsx - TypeError: 'NoneType' objec...
FAILED tests/messages/test_mofile.py::ReadMoTestCase::test_basics - _pickle.U...
FAILED tests/messages/test_mofile.py::WriteMoTestCase::test_empty_translation_with_fallback
FAILED tests/messages/test_mofile.py::WriteMoTestCase::test_sorting - Asserti...
FAILED tests/messages/test_normalized_string.py::test_normalized_string - Att...
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_abort_invalid_po_file
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_applies_specified_encoding_during_read
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_encoding_header_read
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_fuzzy_header - Typ...
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_header_entry - Typ...
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_invalid_pofile_with_abort_flag
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_locale_gets_overridden_by_file
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_missing_plural - T...
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_missing_plural_in_the_middle
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_more_than_two_plural_forms
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_multi_line_obsolete_message
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_multiline_context
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_not_fuzzy_header
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_obsolete_message
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_obsolete_message_ignored
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_obsolete_message_with_context
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_obsolete_plural_with_square_brackets
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_plural_forms_header_parsed
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_plural_with_square_brackets
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_preserve_domain - ...
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_preserve_locale - ...
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_read_multiline - T...
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_single_plural_form
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_singular_plural_form
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_unit_before_obsolete_is_not_obsoleted
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_unit_following_multi_line_obsolete_message
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_with_context - Typ...
FAILED tests/messages/test_pofile.py::ReadPoTestCase::test_with_context_two
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_duplicate_comments
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_file_sorted_po - ...
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_file_with_no_lineno
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_include_lineno - ...
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_join_locations - ...
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_no_include_lineno
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_no_wrap_and_width_behaviour_on_comments
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_po_with_multiline_obsolete_message
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_po_with_obsolete_message
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_po_with_obsolete_message_ignored
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_po_with_previous_msgid
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_po_with_previous_msgid_plural
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_pot_with_translator_comments
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_silent_location_fallback
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_sorted_po - asser...
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_sorted_po_context
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_wrap_locations_with_hyphens
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_wrap_long_lines
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_wrap_long_lines_in_header
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_wrap_long_lines_with_long_word
FAILED tests/messages/test_pofile.py::WritePoTestCase::test_write_po_file_with_specified_charset
FAILED tests/messages/test_pofile.py::PofileFunctionsTestCase::test_denormalize_on_msgstr_without_empty_first_line
FAILED tests/messages/test_pofile.py::PofileFunctionsTestCase::test_unescape
FAILED tests/messages/test_pofile.py::PofileFunctionsTestCase::test_unescape_of_quoted_newline
FAILED tests/messages/test_pofile.py::test_unknown_language_roundtrip - Attri...
FAILED tests/messages/test_pofile.py::test_unknown_language_write - Attribute...
FAILED tests/messages/test_setuptools_frontend.py::test_extract_distutils_keyword_arg_388[LW_-expected0]
FAILED tests/messages/test_setuptools_frontend.py::test_extract_distutils_keyword_arg_388[LW_ QQ Q-expected1]
FAILED tests/messages/test_setuptools_frontend.py::test_extract_distutils_keyword_arg_388[yiy         aia-expected2]
FAILED tests/messages/test_setuptools_frontend.py::test_setuptools_commands
FAILED tests/test_date_intervals.py::test_format_interval_same_instant_1 - As...
FAILED tests/test_date_intervals.py::test_format_interval_same_instant_2 - As...
FAILED tests/test_date_intervals.py::test_format_interval_no_difference - Ass...
FAILED tests/test_date_intervals.py::test_format_interval_in_tz[pytz.timezone]
FAILED tests/test_dates.py::test_get_timezone_gmt[pytz.timezone] - AttributeE...
FAILED tests/test_dates.py::test_get_timezone_name_tzinfo[pytz.timezone-Europe/Berlin-params2-Mitteleurop\xe4ische Zeit]
FAILED tests/test_dates.py::test_get_timezone_name_tzinfo[pytz.timezone-Europe/Berlin-params3-Hor\xe1rio da Europa Central]
FAILED tests/test_dates.py::test_get_timezone_name_tzinfo[pytz.timezone-America/St_Johns-params4-Neufundland-Zeit]
FAILED tests/test_dates.py::test_get_timezone_name_time_pytz[America/Los_Angeles-params0-Pacific Standard Time-pytz.timezone]
FAILED tests/test_dates.py::test_get_timezone_name_time_pytz[America/Los_Angeles-params2-PST-pytz.timezone]
FAILED tests/test_dates.py::test_format_datetime[pytz.timezone] - AssertionEr...
FAILED tests/test_dates.py::test_format_time[pytz.timezone] - AssertionError:...
FAILED tests/test_dates.py::test_format_skeleton[pytz.timezone] - AssertionEr...
FAILED tests/test_dates.py::test_no_inherit_metazone_formatting[pytz.timezone]
FAILED tests/test_support.py::TestFormat::test_format_datetime[pytz.timezone]
FAILED tests/test_support.py::TestFormat::test_format_time[pytz.timezone] - A...
FAILED tests/test_date_intervals.py::test_format_interval_in_tz[zoneinfo.ZoneInfo]
FAILED tests/test_dates.py::test_get_timezone_gmt[zoneinfo.ZoneInfo] - Attrib...
FAILED tests/test_dates.py::test_get_timezone_name_tzinfo[zoneinfo.ZoneInfo-Europe/Berlin-params2-Mitteleurop\xe4ische Zeit]
FAILED tests/test_dates.py::test_get_timezone_name_tzinfo[zoneinfo.ZoneInfo-Europe/Berlin-params3-Hor\xe1rio da Europa Central]
FAILED tests/test_dates.py::test_get_timezone_name_tzinfo[zoneinfo.ZoneInfo-America/St_Johns-params4-Neufundland-Zeit]
FAILED tests/test_dates.py::test_format_datetime[zoneinfo.ZoneInfo] - Asserti...
FAILED tests/test_dates.py::test_format_time[zoneinfo.ZoneInfo] - AssertionEr...
FAILED tests/test_dates.py::test_format_skeleton[zoneinfo.ZoneInfo] - Asserti...
FAILED tests/test_dates.py::test_no_inherit_metazone_formatting[zoneinfo.ZoneInfo]
FAILED tests/test_support.py::TestFormat::test_format_datetime[zoneinfo.ZoneInfo]
FAILED tests/test_support.py::TestFormat::test_format_time[zoneinfo.ZoneInfo]
FAILED tests/test_date_intervals.py::test_format_interval_12_hour - Assertion...
FAILED tests/test_dates.py::test_get_era_names - AssertionError: assert 'AD' ...
FAILED tests/test_dates.py::test_format_timedelta - AssertionError: assert '0...
FAILED tests/test_dates.py::test_datetime_format_get_week_number - assert 2 == 1
FAILED tests/test_dates.py::test_zh_TW_format - AssertionError: assert '12:34...
FAILED tests/test_smoke.py::test_smoke_units[agq] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[am] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[ar] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[ar_EG] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[ar_IL] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[ca_ES_VALENCIA] - AssertionError...
FAILED tests/test_smoke.py::test_smoke_units[de] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[de_AT] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[de_DE] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[ee] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[el_GR] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[en] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[en_150] - AssertionError: assert...
FAILED tests/test_smoke.py::test_smoke_units[en_GB] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[en_US] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[en_US_POSIX] - AssertionError: a...
FAILED tests/test_smoke.py::test_smoke_units[es] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[es_419] - AssertionError: assert...
FAILED tests/test_smoke.py::test_smoke_units[es_AR] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[es_CO] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[es_ES] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[es_GT] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[es_US] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[fi] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[fi_FI] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[fr] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[fr_CA] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[fr_FR] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[gv] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[ii] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[it] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[ja] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[ja_JP] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[kw_GB] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[lt_LT] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[mk] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[nb] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[ne] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[nl_NL] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[pa_Arab] - AssertionError: asser...
FAILED tests/test_smoke.py::test_smoke_units[pl] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[pt] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[pt_BR] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[ro] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[root] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[ru] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[ru_RU] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[sv] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[sv_SE] - AssertionError: assert ...
FAILED tests/test_smoke.py::test_smoke_units[sw] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[th] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[yav] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[zh] - AssertionError: assert None
FAILED tests/test_smoke.py::test_smoke_units[zh_Hans_CN] - AssertionError: as...
FAILED tests/test_smoke.py::test_smoke_units[zh_Hans_SG] - AssertionError: as...
FAILED tests/test_smoke.py::test_smoke_units[zh_Hant] - AssertionError: asser...
FAILED tests/test_smoke.py::test_smoke_units[zh_Hant_TW] - AssertionError: as...
FAILED tests/test_support.py::LazyProxyTestCase::test_can_deepcopy_proxy - as...
FAILED tests/test_support.py::LazyProxyTestCase::test_handle_attribute_error
FAILED tests/test_support.py::TestFormat::test_format_number - TypeError: For...
FAILED tests/test_support.py::TestFormat::test_format_decimal - TypeError: Fo...
FAILED tests/test_support.py::TestFormat::test_format_compact_decimal - TypeE...
FAILED tests/test_support.py::TestFormat::test_format_currency - TypeError: F...
FAILED tests/test_support.py::TestFormat::test_format_compact_currency - Type...
FAILED tests/test_support.py::TestFormat::test_format_percent - TypeError: Fo...
FAILED tests/test_support.py::TestFormat::test_format_scientific - TypeError:...
FAILED tests/test_support.py::test_lazy_proxy - TypeError: can only concatena...
FAILED tests/test_support.py::test_catalog_merge_files - AssertionError: asse...
ERROR tests/messages/test_checkers.py
ERROR tests/messages/test_frontend.py
ERROR tests/messages/test_plurals.py - babel.core.UnknownLocaleError: unknown...
============= 254 failed, 644 passed, 5 skipped, 3 errors in 2.66s =============