← 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: 2016-04-21 05:06:57 UTC
  • mfrom: (6603.4.1 bzr)
  • Revision ID: pqm@pqm.ubuntu.com-20160421050657-ygnzfybewvudf1j9
(richard-wilbur) Use initial_comment as commit_message for lp_propose.(Shawn
 Wang) (Shawn Wang)

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, 2016 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):
40
46
        self.assertTrue('number' in s)
41
47
        self.assertFalse('color' in s)
42
48
        self.assertFalse('42' in s)
43
 
        self.assertEquals(list(s.iter_pairs()),
 
49
        self.assertEqual(list(s.iter_pairs()),
44
50
                [('name', 'fred'), ('number', '42')])
45
 
        self.assertEquals(s.get('number'), '42')
46
 
        self.assertEquals(s.get('name'), 'fred')
 
51
        self.assertEqual(s.get('number'), '42')
 
52
        self.assertEqual(s.get('name'), 'fred')
47
53
 
48
54
    def test_value_checks(self):
49
55
        """rio checks types on construction"""
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):
62
68
    def test_to_lines(self):
63
69
        """Write simple rio stanza to string"""
64
70
        s = Stanza(number='42', name='fred')
65
 
        self.assertEquals(list(s.to_lines()),
 
71
        self.assertEqual(list(s.to_lines()),
66
72
                ['name: fred\n',
67
73
                 'number: 42\n'])
68
74
 
70
76
        """Convert rio Stanza to dictionary"""
71
77
        s = Stanza(number='42', name='fred')
72
78
        sd = s.as_dict()
73
 
        self.assertEquals(sd, dict(number='42', name='fred'))
 
79
        self.assertEqual(sd, dict(number='42', name='fred'))
74
80
 
75
81
    def test_to_file(self):
76
82
        """Write rio to file"""
96
102
''')
97
103
        tmpf.seek(0)
98
104
        s2 = read_stanza(tmpf)
99
 
        self.assertEquals(s, s2)
 
105
        self.assertEqual(s, s2)
100
106
 
101
107
    def test_read_stanza(self):
102
108
        """Load stanza from string"""
109
115
        s = read_stanza(lines)
110
116
        self.assertTrue('revision' in s)
111
117
        self.assertEqualDiff(s.get('revision'), 'mbp@sourcefrog.net-123-abc')
112
 
        self.assertEquals(list(s.iter_pairs()),
 
118
        self.assertEqual(list(s.iter_pairs()),
113
119
                [('revision', 'mbp@sourcefrog.net-123-abc'),
114
120
                 ('timestamp', '1130653962'),
115
121
                 ('timezone', '36000'),
116
122
                 ('committer', "Martin Pool <mbp@test.sourcefrog.net>")])
117
 
        self.assertEquals(len(s), 4)
 
123
        self.assertEqual(len(s), 4)
118
124
 
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())
126
 
        self.assertEquals(s, s2)
127
 
        self.assertEquals(s.get_all('a'), map(str, [10, 100, 1000]))
128
 
        self.assertEquals(s.get_all('b'), map(str, [20, 200, 2000]))
 
132
        self.assertEqual(s, s2)
 
133
        self.assertEqual(s.get_all('a'), map(str, [10, 100, 1000]))
 
134
        self.assertEqual(s.get_all('b'), map(str, [20, 200, 2000]))
129
135
 
130
136
    def test_backslash(self):
131
137
        s = Stanza(q='\\')
132
138
        t = s.to_string()
133
139
        self.assertEqualDiff(t, 'q: \\\n')
134
140
        s2 = read_stanza(s.to_lines())
135
 
        self.assertEquals(s, s2)
 
141
        self.assertEqual(s, s2)
136
142
 
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
""")
147
153
        s2 = read_stanza(s.to_lines())
148
 
        self.assertEquals(s, s2)
 
154
        self.assertEqual(s, s2)
149
155
 
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())
160
 
        self.assertEquals(s, s2)
 
166
        self.assertEqual(s, s2)
161
167
        self.rio_file_stanzas([s])
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='\\"\\"',
174
180
                   )
175
181
        s2 = read_stanza(s.to_lines())
176
 
        self.assertEquals(s, s2)
 
182
        self.assertEqual(s, s2)
177
183
        # apparent bug in read_stanza
178
184
        # s3 = read_stanza(self.stanzas_to_str([s]))
179
 
        # self.assertEquals(s, s3)
 
185
        # self.assertEqual(s, s3)
180
186
 
181
187
    def test_read_empty(self):
182
188
        """Detect end of rio file"""
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'), ])
224
238
""")
225
239
        tmpf.seek(0)
226
240
        s = read_stanza(tmpf)
227
 
        self.assertEquals(s, Stanza(version_header='1'))
 
241
        self.assertEqual(s, Stanza(version_header='1'))
228
242
        s = read_stanza(tmpf)
229
 
        self.assertEquals(s, Stanza(name="foo", val='123'))
 
243
        self.assertEqual(s, Stanza(name="foo", val='123'))
230
244
        s = read_stanza(tmpf)
231
245
        self.assertEqualDiff(s.get('name'), 'quoted')
232
246
        self.assertEqualDiff(s.get('address'), '  "Willowglen"\n  42 Wallaby Way\n  Sydney')
233
247
        s = read_stanza(tmpf)
234
 
        self.assertEquals(s, Stanza(name="bar", val='129319'))
 
248
        self.assertEqual(s, Stanza(name="bar", val='129319'))
235
249
        s = read_stanza(tmpf)
236
 
        self.assertEquals(s, None)
 
250
        self.assertEqual(s, None)
237
251
        self.check_rio_file(tmpf)
238
252
 
239
253
    def check_rio_file(self, real_file):
240
254
        real_file.seek(0)
241
255
        read_write = rio_file(RioReader(real_file)).read()
242
256
        real_file.seek(0)
243
 
        self.assertEquals(read_write, real_file.read())
 
257
        self.assertEqual(read_write, real_file.read())
244
258
 
245
259
    @staticmethod
246
260
    def stanzas_to_str(stanzas):
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
301
315
        for expected in expected_vals:
302
316
            stanza = read_stanza(tmpf)
303
317
            self.rio_file_stanzas([stanza])
304
 
            self.assertEquals(len(stanza), 1)
 
318
            self.assertEqual(len(stanza), 1)
305
319
            self.assertEqualDiff(stanza.get('s'), expected)
306
320
 
307
321
    def test_write_empty_stanza(self):
308
322
        """Write empty stanza"""
309
323
        l = list(Stanza().to_lines())
310
 
        self.assertEquals(l, [])
 
324
        self.assertEqual(l, [])
311
325
 
312
326
    def test_rio_raises_type_error(self):
313
327
        """TypeError on adding invalid type to Stanza"""
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
 
        self.assertEquals(s.get('foo'), uni_data)
 
339
        self.assertEqual(s.get('foo'), uni_data)
328
340
        raw_lines = s.to_lines()
329
 
        self.assertEquals(raw_lines,
 
341
        self.assertEqual(raw_lines,
330
342
                ['foo: ' + uni_data.encode('utf-8') + '\n'])
331
343
        new_s = read_stanza(raw_lines)
332
 
        self.assertEquals(new_s.get('foo'), uni_data)
333
 
 
 
344
        self.assertEqual(new_s.get('foo'), uni_data)
 
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')