def test_msgid_comments(self):
"""Tests that msgid comments don't feature anywhere."""
posource = 'msgid "_: Capital. ACRONYMN. (msgid) comment 3. %d Extra sentence.\\n"\n"cow"\nmsgstr "koei"\n'
pofile = self.parse_text(posource)
filter_result = self.filter(pofile)
if headerless_len(filter_result.units):
print first_translatable(filter_result)
assert headerless_len(filter_result.units) == 0
def test_msgid_comments(self):
"""Tests that msgid comments don't feature anywhere."""
posource = 'msgid "_: Capital. ACRONYMN. (msgid) comment 3. %d Extra sentence.\\n"\n"cow"\nmsgstr "koei"\n'
pofile = self.parse_text(posource)
filter_result = self.filter(pofile)
if headerless_len(filter_result.units):
print first_translatable(filter_result)
assert headerless_len(filter_result.units) == 0
def test_newlines(self):
"""Tests that things keep working with empty entries"""
minicsv = '"source","target"\r\n"yellow pencil","żółty\\nołówek"'
pofile = self.csv2po(minicsv)
assert pofile.findunit("yellow pencil") is not None
assert pofile.findunit("yellow pencil").target == "żółty\\nołówek"
assert headerless_len(pofile.units) == 1
def test_unicode(self):
"""tests that we can handle UTF-8 encoded characters when there is no
known header specified encoding"""
self.unit.source = u'Bézier curve'
self.unit.target = u'Bézier-kurwe'
filter_result = self.filter(self.translationstore)
assert headerless_len(filter_result.units) == 0
def test_simplegrep_locations(self):
"""grep for a string in the location comments"""
posource = '#: test.c\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "test.c", ["--search=locations"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "rest.c", ["--search=locations"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_non_existant_check(self):
"""check that we report an error if a user tries to run a non-existant test"""
filter_result = self.filter(self.translationstore,
cmdlineoptions=["-t nonexistant"])
# TODO Not sure how to check for the stderror result of: warning: could
# not find filter nonexistant
assert headerless_len(filter_result.units) == 0
def test_empties(self):
"""Tests that things keep working with empty entries"""
minipo = 'msgid "Source"\nmsgstr ""\n\nmsgid ""\nmsgstr ""'
csvfile = self.po2csv(minipo)
assert csvfile.findunit("Source") is not None
assert csvfile.findunit("Source").target == ""
assert headerless_len(csvfile.units) == 1
def test_empties(self):
"""Tests that things keep working with empty entries"""
minicsv = ',SomeSource,'
pofile = self.csv2po(minicsv)
assert pofile.findunit("SomeSource") is not None
assert pofile.findunit("SomeSource").target == ""
assert headerless_len(pofile.units) == 1
def test_keep_translations(self):
"""check that we can grep unicode messages and use unicode regex search strings"""
posource = '#: schemas.in\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "schemas.in", ["--invert-match", "--keep-translations", "--search=locations"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "schemas.in", ["--invert-match", "--search=locations"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_simplegrep_locations(self):
"""grep for a string in the location comments"""
posource = '#: test.c\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "test.c", ["--search=locations"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "rest.c", ["--search=locations"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_empties(self):
"""Tests that things keep working with empty entries"""
minicsv = ',SomeSource,'
pofile = self.csv2po(minicsv)
assert pofile.findunit("SomeSource") is not None
assert pofile.findunit("SomeSource").target == ""
assert headerless_len(pofile.units) == 1
def test_escaped_newlines(self):
"""Tests that things keep working with escaped newlines"""
minicsv = '"source","target"\r\n"yellow pencil","żółty\\nołówek"'
pofile = self.csv2po(minicsv)
assert pofile.findunit("yellow pencil") is not None
assert pofile.findunit("yellow pencil").target == "żółty\\nołówek"
assert headerless_len(pofile.units) == 1
def test_simplegrep_comments(self):
"""grep for a string in the comments"""
posource = '# (review) comment\n#: test.c\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "review", ["--search=comment"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "test", ["--search=comment"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_simplegrep_comments(self):
"""grep for a string in the comments"""
posource = '# (review) comment\n#: test.c\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "review", ["--search=comment"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "test", ["--search=comment"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_simplegrep_msgstr(self):
"""grep for a string in the target"""
posource = '#: test.c\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "rest", ["--search=msgstr"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "test", ["--search=msgstr"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_keep_translations(self):
"""check that we can grep unicode messages and use unicode regex search strings"""
posource = '#: schemas.in\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "schemas.in", ["--invert-match", "--keep-translations", "--search=locations"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "schemas.in", ["--invert-match", "--search=locations"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_unicode(self):
"""tests that we can handle UTF-8 encoded characters when there is no
known header specified encoding"""
self.unit.source = u'Bézier curve'
self.unit.target = u'Bézier-kurwe'
filter_result = self.filter(self.translationstore)
assert headerless_len(filter_result.units) == 0
def test_simplegrep_msgstr(self):
"""grep for a string in the target"""
posource = '#: test.c\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "rest", ["--search=msgstr"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "test", ["--search=msgstr"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_empties(self):
"""Tests that things keep working with empty entries"""
minipo = 'msgid "Source"\nmsgstr ""\n\nmsgid ""\nmsgstr ""'
csvfile = self.po2csv(minipo)
assert csvfile.findunit("Source") is not None
assert csvfile.findunit("Source").target == ""
assert headerless_len(csvfile.units) == 1
def test_test_against_review(self):
"""test whether to run tests against translations marked for review"""
self.unit.markreviewneeded()
filter_result = self.filter(self.translationstore, cmdlineoptions=["--review"])
assert first_translatable(filter_result).isreview()
filter_result = self.filter(self.translationstore, cmdlineoptions=["--noreview"])
assert headerless_len(filter_result.units) == 0
# Re-initialize the translation store object.
self.setup_method(self)
filter_result = self.filter(self.translationstore, cmdlineoptions=["--review"])
assert headerless_len(filter_result.units) == 0
filter_result = self.filter(self.translationstore, cmdlineoptions=["--noreview"])
assert headerless_len(filter_result.units) == 0
def test_notes(self):
"""tests the optional adding of notes"""
# let's make sure we trigger the 'long' and/or 'doubleword' test
self.unit.target = "asdf asdf asdf asdf asdf asdf asdf"
filter_result = self.filter(self.translationstore)
assert headerless_len(filter_result.units) == 1
assert first_translatable(filter_result).geterrors()
# now we remove the existing error. self.unit is changed since we copy
# units - very naughty
if isinstance(self.unit, xliff.xliffunit):
self.unit.removenotes(origin="pofilter")
else:
self.unit.removenotes()
filter_result = self.filter(self.translationstore, cmdlineoptions=["--nonotes"])
assert headerless_len(filter_result.units) == 1
assert len(first_translatable(filter_result).geterrors()) == 0
def test_isreview(self):
"""tests the extraction of items marked review"""
filter_result = self.filter(self.translationstore, cmdlineoptions=["--test=isreview"])
assert headerless_len(filter_result.units) == 0
self.unit.markreviewneeded()
filter_result = self.filter(self.translationstore, cmdlineoptions=["--test=isreview"])
assert first_translatable(filter_result).isreview()
def test_notes(self):
"""tests the optional adding of notes"""
# let's make sure we trigger the 'long' and/or 'doubleword' test
self.unit.target = u"asdf asdf asdf asdf asdf asdf asdf"
filter_result = self.filter(self.translationstore)
assert headerless_len(filter_result.units) == 1
assert first_translatable(filter_result).geterrors()
# now we remove the existing error. self.unit is changed since we copy
# units - very naughty
if isinstance(self.unit, xliff.xliffunit):
self.unit.removenotes(origin='pofilter')
else:
self.unit.removenotes()
filter_result = self.filter(self.translationstore, cmdlineoptions=["--nonotes"])
assert headerless_len(filter_result.units) == 1
assert len(first_translatable(filter_result).geterrors()) == 0
def test_non_existant_check(self):
"""check that we report an error if a user tries to run a non-existant
test"""
filter_result = self.filter(self.translationstore,
cmdlineoptions=["-t nonexistant"])
# TODO Not sure how to check for the stderror result of: warning: could
# not find filter nonexistant
assert headerless_len(filter_result.units) == 0
def test_preconditions(self):
"""tests that the preconditions work correctly"""
self.unit.source = "File"
self.unit.target = ""
filter_result = self.filter(self.translationstore)
# We should only get one error (untranslated), and nothing else
assert headerless_len(filter_result.units) == 1
unit = first_translatable(filter_result)
assert len(unit.geterrors()) == 1
def test_simplegrep_locations_with_comment_enabled(self):
"""grep for a string in "locations", while also "comment" is checked
see http://bugs.locamotion.org/show_bug.cgi?id=1036
"""
posource = '# (review) comment\n#: test.c\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "test", ["--search=comment", "--search=locations"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "rest", ["--search=comment", "--search=locations"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_simplegrep_locations_with_comment_enabled(self):
"""grep for a string in "locations", while also "comment" is checked
see https://github.com/translate/translate/issues/1036
"""
posource = '# (review) comment\n#: test.c\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "test", ["--search=comment", "--search=locations"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "rest", ["--search=comment", "--search=locations"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_minimal(self):
minixlf = self.xliffskeleton % '''<trans-unit>
<source>red</source>
<target>rooi</target>
</trans-unit>'''
pofile = self.xliff2po(minixlf)
assert headerless_len(pofile.units) == 1
assert pofile.translate("red") == "rooi"
assert pofile.translate("bla") is None
def test_preconditions(self):
"""tests that the preconditions work correctly"""
self.unit.source = "File"
self.unit.target = ""
filter_result= self.filter(self.translationstore)
# We should only get one error (untranslated), and nothing else
assert headerless_len(filter_result.units) == 1
unit = first_translatable(filter_result)
assert len(unit.geterrors()) == 1
def test_simplegrep_locations_with_comment_enabled(self):
"""grep for a string in "locations", while also "comment" is checked
see http://bugs.locamotion.org/show_bug.cgi?id=1036
"""
posource = '# (review) comment\n#: test.c\nmsgid "test"\nmsgstr "rest"\n'
poresult = self.pogrep(posource, "test", ["--search=comment", "--search=locations"])
assert poresult.index(posource) >= 0
poresult = self.pogrep(posource, "rest", ["--search=comment", "--search=locations"])
assert headerless_len(po.pofile(poresult).units) == 0
def test_test_against_fuzzy(self):
"""test whether to run tests against fuzzy translations"""
self.unit.markfuzzy()
filter_result = self.filter(self.translationstore, cmdlineoptions=["--fuzzy"])
assert "isfuzzy" in first_translatable(filter_result).geterrors()
filter_result = self.filter(self.translationstore, cmdlineoptions=["--nofuzzy"])
assert headerless_len(filter_result.units) == 0
# Re-initialize the translation store object in order to get an unfuzzy
# unit with no filter notes.
self.setup_method(self)
filter_result = self.filter(self.translationstore, cmdlineoptions=["--fuzzy"])
assert headerless_len(filter_result.units) == 0
filter_result = self.filter(self.translationstore, cmdlineoptions=["--nofuzzy"])
assert headerless_len(filter_result.units) == 0
def test_test_against_fuzzy(self):
"""test whether to run tests against fuzzy translations"""
self.unit.markfuzzy()
filter_result = self.filter(self.translationstore, cmdlineoptions=["--fuzzy"])
assert first_translatable(filter_result).geterrors().has_key('isfuzzy')
filter_result = self.filter(self.translationstore, cmdlineoptions=["--nofuzzy"])
assert headerless_len(filter_result.units) == 0
# Re-initialize the translation store object in order to get an unfuzzy unit
# with no filter notes.
self.setup_method(self)
filter_result = self.filter(self.translationstore, cmdlineoptions=["--fuzzy"])
assert headerless_len(filter_result.units) == 0
filter_result = self.filter(self.translationstore, cmdlineoptions=["--nofuzzy"])
assert headerless_len(filter_result.units) == 0
def test_isfuzzy(self):
"""tests the extraction of items marked fuzzy"""
self.unit.markfuzzy()
filter_result = self.filter(self.translationstore, cmdlineoptions=["--test=isfuzzy"])
assert first_translatable(filter_result).geterrors().has_key('isfuzzy')
self.unit.markfuzzy(False)
filter_result = self.filter(self.translationstore, cmdlineoptions=["--test=isfuzzy"])
assert headerless_len(filter_result.units) == 0
def test_isreview(self):
"""tests the extraction of items marked review"""
filter_result = self.filter(self.translationstore,
cmdlineoptions=["--test=isreview"])
assert headerless_len(filter_result.units) == 0
self.unit.markreviewneeded()
filter_result = self.filter(self.translationstore,
cmdlineoptions=["--test=isreview"])
assert first_translatable(filter_result).isreview()
def test_test_against_review(self):
"""test whether to run tests against translations marked for review"""
self.unit.markreviewneeded()
filter_result = self.filter(self.translationstore, cmdlineoptions=["--review"])
assert first_translatable(filter_result).isreview()
filter_result = self.filter(
self.translationstore, cmdlineoptions=["--noreview"]
)
assert headerless_len(filter_result.units) == 0
# Re-initialize the translation store object.
self.setup_method(self)
filter_result = self.filter(self.translationstore, cmdlineoptions=["--review"])
assert headerless_len(filter_result.units) == 0
filter_result = self.filter(
self.translationstore, cmdlineoptions=["--noreview"]
)
assert headerless_len(filter_result.units) == 0
def test_isfuzzy(self):
"""tests the extraction of items marked fuzzy"""
self.unit.markfuzzy()
filter_result = self.filter(self.translationstore,
cmdlineoptions=["--test=isfuzzy"])
assert "isfuzzy" in first_translatable(filter_result).geterrors()
self.unit.markfuzzy(False)
filter_result = self.filter(self.translationstore,
cmdlineoptions=["--test=isfuzzy"])
assert headerless_len(filter_result.units) == 0
def test_simple(self):
""" Test the most basic resx conversion """
resx_source = self.XMLskeleton % '''<data name="key" xml:space="preserve">
<value>A simple string</value>
</data>'''
poexpected = '''#: key
msgid "A simple string"
msgstr ""
'''
po_result = self.resx2po(resx_source)
assert str(po_result.units[1]) == poexpected
assert headerless_len(po_result.units) == 1
def test_simple(self):
""" Test the most basic resx conversion """
resx_source = self.XMLskeleton % '''<data name="key" xml:space="preserve">
<value>A simple string</value>
</data>'''
poexpected = '''#: key
msgid "A simple string"
msgstr ""
'''
po_result = self.resx2po(resx_source)
assert str(po_result.units[1]) == poexpected
assert headerless_len(po_result.units) == 1
def test_plurals(self):
"""Tests fuzzyness"""
minixlf = self.xliffskeleton % '''<group id="1" restype="x-gettext-plurals">
<trans-unit id="1[0]" xml:space="preserve">
<source>cow</source>
<target>inkomo</target>
</trans-unit>
<trans-unit id="1[1]" xml:space="preserve">
<source>cows</source>
<target>iinkomo</target>
</trans-unit>
</group>'''
pofile = self.xliff2po(minixlf)
print(bytes(pofile))
potext = bytes(pofile).decode('utf-8')
assert headerless_len(pofile.units) == 1
assert potext.index('msgid_plural "cows"')
assert potext.index('msgstr[0] "inkomo"')
assert potext.index('msgstr[1] "iinkomo"')
def test_fuzzy(self):
"""Tests fuzzyness"""
minixlf = self.xliffskeleton % '''<trans-unit approved="no">
<source>book</source>
</trans-unit>
<trans-unit id="2" approved="yes">
<source>nonsense</source>
<target>matlhapolosa</target>
</trans-unit>
<trans-unit id="2" approved="no">
<source>verb</source>
<target state="needs-review-translation">lediri</target>
</trans-unit>'''
pofile = self.xliff2po(minixlf)
assert pofile.translate("nonsense") == "matlhapolosa"
assert pofile.translate("verb") == "lediri"
assert pofile.translate("book") is None
assert pofile.translate("bla") is None
assert headerless_len(pofile.units) == 3
#TODO: decide if this one should be fuzzy:
#assert pofile.units[0].isfuzzy()
assert not pofile.units[2].isfuzzy()
assert pofile.units[3].isfuzzy()
def test_list_all_tests(self):
"""lists all available tests"""
filter_result = self.filter(self.translationstore, cmdlineoptions=["-l"])
# TODO again not sure how to check the stderror output
assert headerless_len(filter_result.units) == 0
def test_variables_across_lines(self):
"""Test that variables can span lines and still fail/pass"""
self.unit.source = '"At &timeBombURL."\n"label;."'
self.unit.target = '"Tydens &tydBombURL."\n"etiket;."'
filter_result = self.filter(self.translationstore)
assert headerless_len(filter_result.units) == 0
def test_simplepass(self):
"""checks that an obviously correct string passes"""
filter_result = self.filter(self.translationstore)
assert headerless_len(filter_result.units) == 0
def test_list_all_tests(self):
"""lists all available tests"""
filter_result = self.filter(self.translationstore, cmdlineoptions=["-l"])
# TODO again not sure how to check the stderror output
assert headerless_len(filter_result.units) == 0
def singleelement(self, storage):
"""checks that the pofile contains a single non-header element, and returns it"""
assert headerless_len(storage.units) == 1
return first_translatable(storage)
def singleelement(self, storage):
"""checks that the pofile contains a single non-header element, and returns it"""
assert headerless_len(storage.units) == 1
return first_translatable(storage)
def test_variables_across_lines(self):
"""Test that variables can span lines and still fail/pass"""
self.unit.source = '"At &timeBombURL."\n"label;."'
self.unit.target = '"Tydens &tydBombURL."\n"etiket;."'
filter_result = self.filter(self.translationstore)
assert headerless_len(filter_result.units) == 0
def test_simplepass(self):
"""checks that an obviously correct string passes"""
filter_result = self.filter(self.translationstore)
assert headerless_len(filter_result.units) == 0
