/brz/remove-bazaar

# Copyright (C) 2005 by 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""Tests for basic_io serialization

A simple, reproducible structured IO format.

basic_io itself works in Unicode strings.  It is typically encoded to UTF-8,

but this depends on the transport.

"""

import os

import sys

from tempfile import TemporaryFile

from bzrlib.tests import TestCaseInTempDir, TestCase

from bzrlib.basicio import BasicWriter, Stanza, read_stanza, read_stanzas

class TestBasicIO(TestCase):

    def test_stanza(self):

        """Construct basic_io stanza in memory"""

        s = Stanza(number=42, name="fred")

        self.assertTrue('number' in s)

        self.assertFalse('color' in s)

        self.assertFalse(42 in s)

        self.assertEquals(list(s.iter_pairs()),

                [('name', 'fred'), ('number', 42)])

        self.assertEquals(s.get('number'), 42)

        self.assertEquals(s.get('name'), 'fred')

    def test_value_checks(self):

        """basic_io checks types on construction"""

        # these aren't enforced at construction time

        ## self.assertRaises(ValueError,

        ##        Stanza, complex=42 + 3j)

        ## self.assertRaises(ValueError, 

        ##        Stanza, several=range(10))

    def test_to_lines(self):

        """Write simple basic_io stanza to string"""

        s = Stanza(number=42, name='fred')

        self.assertEquals(list(s.to_lines()),

                ['  name "fred"\n',

                 'number 42\n'])

    def test_to_file(self):

        """Write basic_io to file"""

        tmpf = TemporaryFile()

        s = Stanza(a_thing='something with "quotes like \\"this\\""', number=42, name='fred')

        s.write(tmpf)

        tmpf.seek(0)

        self.assertEqualDiff(tmpf.read(), r'''

a_thing "something with \"quotes like \\\"this\\\"\""

   name "fred"

 number 42

'''[1:])

    def test_multiline_string(self):

        """Write basic_io with multiline string"""

        tmpf = TemporaryFile()

        s = Stanza(a=123, motto="war is peace\nfreedom is slavery\nignorance is strength\n",

                   charlie_horse=456)

        s.write(tmpf)

        tmp.seek(0)

        self.assertEqualDiff(tmpf.read(), r'''\

            a 123

        motto "war is peace

freedom is slavery

ignorance is strength

"

charlie_horse 456

''')

    def test_multiline_string(self):

        tmpf = TemporaryFile()

        s = Stanza(motto="war is peace\nfreedom is slavery\nignorance is strength")

        s.write(tmpf)

        tmpf.seek(0)

        self.assertEqualDiff(tmpf.read(), '''\

motto "war is peace

freedom is slavery

ignorance is strength"

''')

        tmpf.seek(0)

        s2 = read_stanza(tmpf)

        self.assertEquals(s, s2)

    def test_read_stanza(self):

        """Load stanza from string"""

        lines = """\

 revision "mbp@sourcefrog.net-123-abc"

timestamp 1130653962

 timezone 36000

committer "Martin Pool <mbp@test.sourcefrog.net>"

""".splitlines(True)

        s = read_stanza(lines)

        self.assertTrue('revision' in s)

        self.assertEqualDiff(s.get('revision'), 'mbp@sourcefrog.net-123-abc')

        self.assertEquals(list(s.iter_pairs()),

                [('revision', 'mbp@sourcefrog.net-123-abc'),

                 ('timestamp', 1130653962),

                 ('timezone', 36000),

                 ('committer', "Martin Pool <mbp@test.sourcefrog.net>")])

        self.assertEquals(len(s), 4)

    def test_repeated_field(self):

        """Repeated field in basic_io"""

        s = Stanza()

        for k, v in [('a', 10), ('b', 20), ('a', 100), ('b', 200), ('a', 1000), ('b', 2000)]:

            s.add(k, v)

        s2 = read_stanza(s.to_lines())

        self.assertEquals(s, s2)

        self.assertEquals(s.get_all('a'), [10, 100, 1000])

        self.assertEquals(s.get_all('b'), [20, 200, 2000])

    def test_longint(self):

        """basic_io packing long integers"""

        s = Stanza(x=-12345678901234567890,

                   y=1<<100)

        lines = s.to_lines()

        s2 = read_stanza(lines)

        self.assertEquals(s, s2)

    def test_quoted_0(self):

        """Backslash quoted cases"""

        s = Stanza(q='\\')

        t = s.to_string()

        self.assertEqualDiff(t, 'q "\\\\"\n')

        s2 = read_stanza(s.to_lines())

        self.assertEquals(s, s2)

    def test_quoted_1(self):

        """Backslash quoted cases"""

        s = Stanza(q=r'\"\"')

        self.assertEqualDiff(s.to_string(), r'q "\\\"\\\""' + '\n')

    def test_quoted_4(self):

        s = Stanza(q=r'""""')

        t = s.to_string()

        self.assertEqualDiff(t, r'q "\"\"\"\""' + '\n')

        s2 = read_stanza(s.to_lines())

        self.assertEquals(s, s2)

    def test_quoted_5(self):

        s = Stanza(q=r'\\\\\"')

        t = s.to_string()

        s2 = read_stanza(s.to_lines())

        self.assertEquals(s, s2)

    def test_quoted_6(self):

        qval = r'''

                "

                \"

'''

        s = Stanza(q=qval)

        t = s.to_string()

        self.log(t)

        s2 = read_stanza(s.to_lines())

        self.assertEquals(s2['q'], qval)

    def test_quoted_7(self):

        qval = r'''

                "

                \"

                \\"

trailing stuff'''

        s = Stanza(q=qval)

        t = s.to_string()

        self.log(t)

        s2 = read_stanza(s.to_lines())

        self.assertEquals(s2['q'], qval)

    def test_quoted_8(self):

        qval = r'''trailing

        quote"'''

        s = Stanza(q=qval)

        t = s.to_string()

        self.log(t)

        s2 = read_stanza(s.to_lines())

        self.assertEquals(s2['q'], qval)

    def test_quoted(self):

        """basic_io quoted string cases"""

        s = Stanza(q1='"hello"', 

                   q2=' "for', 

                   q3='\n\n"for"\n',

                   q4='for\n"\nfor',

                   q5='\n',

                   q6='"', 

                   q7='""',

                   q8='\\',

                   q9='\\"\\"',

                   )

        s2 = read_stanza(s.to_lines())

        self.assertEquals(s, s2)

    def test_read_empty(self):

        """Detect end of basic_io file"""

        s = read_stanza([])

        self.assertEqual(s, None)

        self.assertTrue(s is None)

    def test_read_iter(self):

        """Read several stanzas from file"""

        tmpf = TemporaryFile()

        tmpf.write("""\

version_header 1

name "foo"

val 123

name "bar"

val 129319

""")

        tmpf.seek(0)

        reader = read_stanzas(tmpf)

        read_iter = iter(reader)

        stuff = list(reader)

        self.assertEqual(stuff, 

                [ Stanza(version_header=1),

                  Stanza(name="foo", val=123),

                  Stanza(name="bar", val=129319), ])

    def test_read_several(self):

        """Read several stanzas from file"""

        tmpf = TemporaryFile()

        tmpf.write("""\

version_header 1

name "foo"

val 123

name "quoted"

address "  \\"Willowglen\\"

  42 Wallaby Way

  Sydney"

name "bar"

val 129319

""")

        tmpf.seek(0)

        s = read_stanza(tmpf)

        self.assertEquals(s, Stanza(version_header=1))

        s = read_stanza(tmpf)

        self.assertEquals(s, Stanza(name="foo", val=123))

        s = read_stanza(tmpf)

        self.assertEqualDiff(s.get('name'), 'quoted')

        self.assertEqualDiff(s.get('address'), '  "Willowglen"\n  42 Wallaby Way\n  Sydney')

        s = read_stanza(tmpf)

        self.assertEquals(s, Stanza(name="bar", val=129319))

        s = read_stanza(tmpf)

        self.assertEquals(s, None)

    def test_tricky_quoted(self):

        tmpf = TemporaryFile()

        tmpf.write(r"""

s "\"one\""

s "

\"one\"

"

s "\""

s "\"\""

s "\"\"\""

s "

"

s "\\"

s "

\\

\\\\

"

s "word\\"

s "quote\""

s "backslashes\\\\\\"

s "both\\\""

"""[1:]) # remove initial newline

        tmpf.seek(0)

        expected_vals = ['"one"',

            '\n"one"\n',

            '"',

            '""',

            '"""',

            '\n',

            '\\',

            '\n\\\n\\\\\n',

            'word\\',

            'quote\"',

            'backslashes\\\\\\',

            'both\\\"',

            ]

        for expected in expected_vals:

            stanza = read_stanza(tmpf)

            self.assertEquals(len(stanza), 1)

            self.assertEqualDiff(stanza.get('s'), expected)

    def test_write_bool(self):

        """Write bool to basic_io"""

        l = list(Stanza(my_bool=True).to_lines())

        self.assertEquals(l, ['my_bool 1\n'])

    def test_write_empty_stanza(self):

        """Write empty stanza"""

        l = list(Stanza().to_lines())

        self.assertEquals(l, [])