~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2011 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

from cStringIO import StringIO

import textwrap

from bzrlib import (

    commands,

    export_pot,

    tests,

    )

import re

class TestEscape(tests.TestCase):

    def test_simple_escape(self):

        self.assertEqual(

                export_pot._escape('foobar'),

                'foobar')

        s = '''foo\nbar\r\tbaz\\"spam"'''

        e = '''foo\\nbar\\r\\tbaz\\\\\\"spam\\"'''

        self.assertEqual(export_pot._escape(s), e)

    def test_complex_escape(self):

        s = '''\\r \\\n'''

        e = '''\\\\r \\\\\\n'''

        self.assertEqual(export_pot._escape(s), e)

class TestNormalize(tests.TestCase):

    def test_single_line(self):

        s = 'foobar'

        e = '"foobar"'

        self.assertEqual(export_pot._normalize(s), e)

        s = 'foo"bar'

        e = '"foo\\"bar"'

        self.assertEqual(export_pot._normalize(s), e)

    def test_multi_lines(self):

        s = 'foo\nbar\n'

        e = '""\n"foo\\n"\n"bar\\n"'

        self.assertEqual(export_pot._normalize(s), e)

        s = '\nfoo\nbar\n'

        e = ('""\n'

             '"\\n"\n'

             '"foo\\n"\n'

             '"bar\\n"')

        self.assertEqual(export_pot._normalize(s), e)

class PoEntryTestCase(tests.TestCase):

    def setUp(self):

        self.overrideAttr(export_pot, '_FOUND_MSGID', set())

        self._outf = StringIO()

        super(PoEntryTestCase, self).setUp()

    def check_output(self, expected):

        self.assertEqual(

                self._outf.getvalue(),

                textwrap.dedent(expected)

                )

class TestPoEntry(PoEntryTestCase):

    def test_simple(self):

        export_pot._poentry(self._outf, 'dummy', 1, "spam")

        export_pot._poentry(self._outf, 'dummy', 2, "ham", 'EGG')

        self.check_output('''\

                #: dummy:1

                msgid "spam"

                msgstr ""

                #: dummy:2

                # EGG

                msgid "ham"

                msgstr ""

                ''')

    def test_duplicate(self):

        export_pot._poentry(self._outf, 'dummy', 1, "spam")

        # This should be ignored.

        export_pot._poentry(self._outf, 'dummy', 2, "spam", 'EGG')

        self.check_output('''\

                #: dummy:1

                msgid "spam"

                msgstr ""\n

                ''')

class TestPoentryPerPergraph(PoEntryTestCase):

    def test_single(self):

        export_pot._poentry_per_paragraph(

                self._outf,

                'dummy',

                10,

                '''foo\nbar\nbaz\n'''

                )

        self.check_output('''\

                #: dummy:10

                msgid ""

                "foo\\n"

                "bar\\n"

                "baz\\n"

                msgstr ""\n

                ''')

    def test_multi(self):

        export_pot._poentry_per_paragraph(

                self._outf,

                'dummy',

                10,

                '''spam\nham\negg\n\nSPAM\nHAM\nEGG\n'''

                )

        self.check_output('''\

                #: dummy:10

                msgid ""

                "spam\\n"

                "ham\\n"

                "egg"

                msgstr ""

                #: dummy:14

                msgid ""

                "SPAM\\n"

                "HAM\\n"

                "EGG\\n"

                msgstr ""\n

                ''')

class TestExportCommandHelp(PoEntryTestCase):

    def test_command_help(self):

        class cmd_Demo(commands.Command):

            __doc__ = """A sample command.

            :Usage:

                bzr demo

            :Examples:

                Example 1::

                    cmd arg1

            Blah Blah Blah

            """

        export_pot._write_command_help(self._outf, cmd_Demo())

        result = self._outf.getvalue()

        # We don't care about filename and lineno here.

        result = re.sub(r'(?m)^#: [^\n]+\n', '', result)

        self.assertEqualDiff(

                'msgid "A sample command."\n'

                'msgstr ""\n'

                '\n'                # :Usage: should not be translated.

                'msgid ""\n'

                '":Examples:\\n"\n'

                '"    Example 1::"\n'

                'msgstr ""\n'

                '\n'

                'msgid "        cmd arg1"\n'

                'msgstr ""\n'

                '\n'

                'msgid "Blah Blah Blah"\n'

                'msgstr ""\n'

                '\n',

                result

                )