← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_rio.py

  • Committer: Patch Queue Manager
  • Date: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_rio.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2009, 2010, 2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for rio serialization
18
18
 
22
22
but this depends on the transport.
23
23
"""
24
24
 
25
 
import cStringIO
26
 
import os
27
 
import sys
 
25
import re
28
26
from tempfile import TemporaryFile
29
27
 
30
 
from bzrlib.tests import TestCaseInTempDir, TestCase
31
 
from bzrlib.rio import (RioWriter, Stanza, read_stanza, read_stanzas, rio_file,
32
 
                        RioReader)
 
28
from bzrlib import (
 
29
    rio,
 
30
    )
 
31
from bzrlib.tests import TestCase
 
32
from bzrlib.rio import (
 
33
    RioReader,
 
34
    Stanza,
 
35
    read_stanza,
 
36
    read_stanzas,
 
37
    rio_file,
 
38
    )
33
39
 
34
40
 
35
41
class TestRio(TestCase):
50
56
        # these aren't enforced at construction time
51
57
        ## self.assertRaises(ValueError,
52
58
        ##        Stanza, complex=42 + 3j)
53
 
        ## self.assertRaises(ValueError, 
 
59
        ## self.assertRaises(ValueError,
54
60
        ##        Stanza, several=range(10))
55
61
 
56
62
    def test_empty_value(self):
119
125
    def test_repeated_field(self):
120
126
        """Repeated field in rio"""
121
127
        s = Stanza()
122
 
        for k, v in [('a', '10'), ('b', '20'), ('a', '100'), ('b', '200'), 
 
128
        for k, v in [('a', '10'), ('b', '20'), ('a', '100'), ('b', '200'),
123
129
                     ('a', '1000'), ('b', '2000')]:
124
130
            s.add(k, v)
125
131
        s2 = read_stanza(s.to_lines())
137
143
    def test_blank_line(self):
138
144
        s = Stanza(none='', one='\n', two='\n\n')
139
145
        self.assertEqualDiff(s.to_string(), """\
140
 
none: 
141
 
one: 
 
146
none:\x20
 
147
one:\x20
142
148
\t
143
 
two: 
 
149
two:\x20
144
150
\t
145
151
\t
146
152
""")
150
156
    def test_whitespace_value(self):
151
157
        s = Stanza(space=' ', tabs='\t\t\t', combo='\n\t\t\n')
152
158
        self.assertEqualDiff(s.to_string(), """\
153
 
combo: 
 
159
combo:\x20
154
160
\t\t\t
155
161
\t
156
 
space:  
 
162
space:\x20\x20
157
163
tabs: \t\t\t
158
164
""")
159
165
        s2 = read_stanza(s.to_lines())
162
168
 
163
169
    def test_quoted(self):
164
170
        """rio quoted string cases"""
165
 
        s = Stanza(q1='"hello"', 
166
 
                   q2=' "for', 
 
171
        s = Stanza(q1='"hello"',
 
172
                   q2=' "for',
167
173
                   q3='\n\n"for"\n',
168
174
                   q4='for\n"\nfor',
169
175
                   q5='\n',
170
 
                   q6='"', 
 
176
                   q6='"',
171
177
                   q7='""',
172
178
                   q8='\\',
173
179
                   q9='\\"\\"',
183
189
        s = read_stanza([])
184
190
        self.assertEqual(s, None)
185
191
        self.assertTrue(s is None)
186
 
        
 
192
 
 
193
    def test_read_nul_byte(self):
 
194
        """File consisting of a nul byte causes an error."""
 
195
        self.assertRaises(ValueError, read_stanza, ['\0'])
 
196
 
 
197
    def test_read_nul_bytes(self):
 
198
        """File consisting of many nul bytes causes an error."""
 
199
        self.assertRaises(ValueError, read_stanza, ['\0' * 100])
 
200
 
187
201
    def test_read_iter(self):
188
202
        """Read several stanzas from file"""
189
203
        tmpf = TemporaryFile()
200
214
        reader = read_stanzas(tmpf)
201
215
        read_iter = iter(reader)
202
216
        stuff = list(reader)
203
 
        self.assertEqual(stuff, 
 
217
        self.assertEqual(stuff,
204
218
                [ Stanza(version_header='1'),
205
219
                  Stanza(name="foo", val='123'),
206
220
                  Stanza(name="bar", val='129319'), ])
255
269
        tmpf.write('''\
256
270
s: "one"
257
271
 
258
 
s: 
 
272
s:\x20
259
273
\t"one"
260
274
\t
261
275
 
265
279
 
266
280
s: """
267
281
 
268
 
s: 
 
282
s:\x20
269
283
\t
270
284
 
271
285
s: \\
272
286
 
273
 
s: 
 
287
s:\x20
274
288
\t\\
275
289
\t\\\\
276
290
\t
320
334
        self.assertRaises(TypeError, s.add, 10, {})
321
335
 
322
336
    def test_rio_unicode(self):
323
 
        # intentionally use cStringIO which doesn't accomodate unencoded unicode objects
324
 
        sio = cStringIO.StringIO()
325
337
        uni_data = u'\N{KATAKANA LETTER O}'
326
338
        s = Stanza(foo=uni_data)
327
339
        self.assertEquals(s.get('foo'), uni_data)
331
343
        new_s = read_stanza(raw_lines)
332
344
        self.assertEquals(new_s.get('foo'), uni_data)
333
345
 
 
346
    def test_rio_to_unicode(self):
 
347
        uni_data = u'\N{KATAKANA LETTER O}'
 
348
        s = Stanza(foo=uni_data)
 
349
        unicode_str = s.to_unicode()
 
350
        self.assertEqual(u'foo: %s\n' % (uni_data,), unicode_str)
 
351
        new_s = rio.read_stanza_unicode(unicode_str.splitlines(True))
 
352
        self.assertEqual(uni_data, new_s.get('foo'))
 
353
 
 
354
    def test_nested_rio_unicode(self):
 
355
        uni_data = u'\N{KATAKANA LETTER O}'
 
356
        s = Stanza(foo=uni_data)
 
357
        parent_stanza = Stanza(child=s.to_unicode())
 
358
        raw_lines = parent_stanza.to_lines()
 
359
        self.assertEqual(['child: foo: ' + uni_data.encode('utf-8') + '\n',
 
360
                          '\t\n',
 
361
                         ], raw_lines)
 
362
        new_parent = read_stanza(raw_lines)
 
363
        child_text = new_parent.get('child')
 
364
        self.assertEqual(u'foo: %s\n' % uni_data, child_text)
 
365
        new_child = rio.read_stanza_unicode(child_text.splitlines(True))
 
366
        self.assertEqual(uni_data, new_child.get('foo'))
 
367
 
 
368
    def mail_munge(self, lines, dos_nl=True):
 
369
        new_lines = []
 
370
        for line in lines:
 
371
            line = re.sub(' *\n', '\n', line)
 
372
            if dos_nl:
 
373
                line = re.sub('([^\r])\n', '\\1\r\n', line)
 
374
            new_lines.append(line)
 
375
        return new_lines
 
376
 
 
377
    def test_patch_rio(self):
 
378
        stanza = Stanza(data='#\n\r\\r ', space=' ' * 255, hash='#' * 255)
 
379
        lines = rio.to_patch_lines(stanza)
 
380
        for line in lines:
 
381
            self.assertContainsRe(line, '^# ')
 
382
            self.assertTrue(72 >= len(line))
 
383
        for line in rio.to_patch_lines(stanza, max_width=12):
 
384
            self.assertTrue(12 >= len(line))
 
385
        new_stanza = rio.read_patch_stanza(self.mail_munge(lines,
 
386
                                                           dos_nl=False))
 
387
        lines = self.mail_munge(lines)
 
388
        new_stanza = rio.read_patch_stanza(lines)
 
389
        self.assertEqual('#\n\r\\r ', new_stanza.get('data'))
 
390
        self.assertEqual(' '* 255, new_stanza.get('space'))
 
391
        self.assertEqual('#'* 255, new_stanza.get('hash'))
 
392
 
 
393
    def test_patch_rio_linebreaks(self):
 
394
        stanza = Stanza(breaktest='linebreak -/'*30)
 
395
        self.assertContainsRe(rio.to_patch_lines(stanza, 71)[0],
 
396
                              'linebreak\\\\\n')
 
397
        stanza = Stanza(breaktest='linebreak-/'*30)
 
398
        self.assertContainsRe(rio.to_patch_lines(stanza, 70)[0],
 
399
                              'linebreak-\\\\\n')
 
400
        stanza = Stanza(breaktest='linebreak/'*30)
 
401
        self.assertContainsRe(rio.to_patch_lines(stanza, 70)[0],
 
402
                              'linebreak\\\\\n')