← 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 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_rio.py
1
 
# Copyright (C) 2005, 2006 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
25
import re
28
 
import sys
29
26
from tempfile import TemporaryFile
30
27
 
31
28
from bzrlib import (
32
29
    rio,
33
30
    )
34
 
from bzrlib.tests import TestCaseInTempDir, TestCase
35
 
from bzrlib.rio import (RioWriter, Stanza, read_stanza, read_stanzas, rio_file,
36
 
                        RioReader)
 
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
    )
37
39
 
38
40
 
39
41
class TestRio(TestCase):
44
46
        self.assertTrue('number' in s)
45
47
        self.assertFalse('color' in s)
46
48
        self.assertFalse('42' in s)
47
 
        self.assertEquals(list(s.iter_pairs()),
 
49
        self.assertEqual(list(s.iter_pairs()),
48
50
                [('name', 'fred'), ('number', '42')])
49
 
        self.assertEquals(s.get('number'), '42')
50
 
        self.assertEquals(s.get('name'), 'fred')
 
51
        self.assertEqual(s.get('number'), '42')
 
52
        self.assertEqual(s.get('name'), 'fred')
51
53
 
52
54
    def test_value_checks(self):
53
55
        """rio checks types on construction"""
54
56
        # these aren't enforced at construction time
55
57
        ## self.assertRaises(ValueError,
56
58
        ##        Stanza, complex=42 + 3j)
57
 
        ## self.assertRaises(ValueError, 
 
59
        ## self.assertRaises(ValueError,
58
60
        ##        Stanza, several=range(10))
59
61
 
60
62
    def test_empty_value(self):
66
68
    def test_to_lines(self):
67
69
        """Write simple rio stanza to string"""
68
70
        s = Stanza(number='42', name='fred')
69
 
        self.assertEquals(list(s.to_lines()),
 
71
        self.assertEqual(list(s.to_lines()),
70
72
                ['name: fred\n',
71
73
                 'number: 42\n'])
72
74
 
74
76
        """Convert rio Stanza to dictionary"""
75
77
        s = Stanza(number='42', name='fred')
76
78
        sd = s.as_dict()
77
 
        self.assertEquals(sd, dict(number='42', name='fred'))
 
79
        self.assertEqual(sd, dict(number='42', name='fred'))
78
80
 
79
81
    def test_to_file(self):
80
82
        """Write rio to file"""
100
102
''')
101
103
        tmpf.seek(0)
102
104
        s2 = read_stanza(tmpf)
103
 
        self.assertEquals(s, s2)
 
105
        self.assertEqual(s, s2)
104
106
 
105
107
    def test_read_stanza(self):
106
108
        """Load stanza from string"""
113
115
        s = read_stanza(lines)
114
116
        self.assertTrue('revision' in s)
115
117
        self.assertEqualDiff(s.get('revision'), 'mbp@sourcefrog.net-123-abc')
116
 
        self.assertEquals(list(s.iter_pairs()),
 
118
        self.assertEqual(list(s.iter_pairs()),
117
119
                [('revision', 'mbp@sourcefrog.net-123-abc'),
118
120
                 ('timestamp', '1130653962'),
119
121
                 ('timezone', '36000'),
120
122
                 ('committer', "Martin Pool <mbp@test.sourcefrog.net>")])
121
 
        self.assertEquals(len(s), 4)
 
123
        self.assertEqual(len(s), 4)
122
124
 
123
125
    def test_repeated_field(self):
124
126
        """Repeated field in rio"""
125
127
        s = Stanza()
126
 
        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'),
127
129
                     ('a', '1000'), ('b', '2000')]:
128
130
            s.add(k, v)
129
131
        s2 = read_stanza(s.to_lines())
130
 
        self.assertEquals(s, s2)
131
 
        self.assertEquals(s.get_all('a'), map(str, [10, 100, 1000]))
132
 
        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]))
133
135
 
134
136
    def test_backslash(self):
135
137
        s = Stanza(q='\\')
136
138
        t = s.to_string()
137
139
        self.assertEqualDiff(t, 'q: \\\n')
138
140
        s2 = read_stanza(s.to_lines())
139
 
        self.assertEquals(s, s2)
 
141
        self.assertEqual(s, s2)
140
142
 
141
143
    def test_blank_line(self):
142
144
        s = Stanza(none='', one='\n', two='\n\n')
143
145
        self.assertEqualDiff(s.to_string(), """\
144
 
none: 
145
 
one: 
 
146
none:\x20
 
147
one:\x20
146
148
\t
147
 
two: 
 
149
two:\x20
148
150
\t
149
151
\t
150
152
""")
151
153
        s2 = read_stanza(s.to_lines())
152
 
        self.assertEquals(s, s2)
 
154
        self.assertEqual(s, s2)
153
155
 
154
156
    def test_whitespace_value(self):
155
157
        s = Stanza(space=' ', tabs='\t\t\t', combo='\n\t\t\n')
156
158
        self.assertEqualDiff(s.to_string(), """\
157
 
combo: 
 
159
combo:\x20
158
160
\t\t\t
159
161
\t
160
 
space:  
 
162
space:\x20\x20
161
163
tabs: \t\t\t
162
164
""")
163
165
        s2 = read_stanza(s.to_lines())
164
 
        self.assertEquals(s, s2)
 
166
        self.assertEqual(s, s2)
165
167
        self.rio_file_stanzas([s])
166
168
 
167
169
    def test_quoted(self):
168
170
        """rio quoted string cases"""
169
 
        s = Stanza(q1='"hello"', 
170
 
                   q2=' "for', 
 
171
        s = Stanza(q1='"hello"',
 
172
                   q2=' "for',
171
173
                   q3='\n\n"for"\n',
172
174
                   q4='for\n"\nfor',
173
175
                   q5='\n',
174
 
                   q6='"', 
 
176
                   q6='"',
175
177
                   q7='""',
176
178
                   q8='\\',
177
179
                   q9='\\"\\"',
178
180
                   )
179
181
        s2 = read_stanza(s.to_lines())
180
 
        self.assertEquals(s, s2)
 
182
        self.assertEqual(s, s2)
181
183
        # apparent bug in read_stanza
182
184
        # s3 = read_stanza(self.stanzas_to_str([s]))
183
 
        # self.assertEquals(s, s3)
 
185
        # self.assertEqual(s, s3)
184
186
 
185
187
    def test_read_empty(self):
186
188
        """Detect end of rio file"""
187
189
        s = read_stanza([])
188
190
        self.assertEqual(s, None)
189
191
        self.assertTrue(s is None)
190
 
        
 
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
 
191
201
    def test_read_iter(self):
192
202
        """Read several stanzas from file"""
193
203
        tmpf = TemporaryFile()
204
214
        reader = read_stanzas(tmpf)
205
215
        read_iter = iter(reader)
206
216
        stuff = list(reader)
207
 
        self.assertEqual(stuff, 
 
217
        self.assertEqual(stuff,
208
218
                [ Stanza(version_header='1'),
209
219
                  Stanza(name="foo", val='123'),
210
220
                  Stanza(name="bar", val='129319'), ])
228
238
""")
229
239
        tmpf.seek(0)
230
240
        s = read_stanza(tmpf)
231
 
        self.assertEquals(s, Stanza(version_header='1'))
 
241
        self.assertEqual(s, Stanza(version_header='1'))
232
242
        s = read_stanza(tmpf)
233
 
        self.assertEquals(s, Stanza(name="foo", val='123'))
 
243
        self.assertEqual(s, Stanza(name="foo", val='123'))
234
244
        s = read_stanza(tmpf)
235
245
        self.assertEqualDiff(s.get('name'), 'quoted')
236
246
        self.assertEqualDiff(s.get('address'), '  "Willowglen"\n  42 Wallaby Way\n  Sydney')
237
247
        s = read_stanza(tmpf)
238
 
        self.assertEquals(s, Stanza(name="bar", val='129319'))
 
248
        self.assertEqual(s, Stanza(name="bar", val='129319'))
239
249
        s = read_stanza(tmpf)
240
 
        self.assertEquals(s, None)
 
250
        self.assertEqual(s, None)
241
251
        self.check_rio_file(tmpf)
242
252
 
243
253
    def check_rio_file(self, real_file):
244
254
        real_file.seek(0)
245
255
        read_write = rio_file(RioReader(real_file)).read()
246
256
        real_file.seek(0)
247
 
        self.assertEquals(read_write, real_file.read())
 
257
        self.assertEqual(read_write, real_file.read())
248
258
 
249
259
    @staticmethod
250
260
    def stanzas_to_str(stanzas):
259
269
        tmpf.write('''\
260
270
s: "one"
261
271
 
262
 
s: 
 
272
s:\x20
263
273
\t"one"
264
274
\t
265
275
 
269
279
 
270
280
s: """
271
281
 
272
 
s: 
 
282
s:\x20
273
283
\t
274
284
 
275
285
s: \\
276
286
 
277
 
s: 
 
287
s:\x20
278
288
\t\\
279
289
\t\\\\
280
290
\t
305
315
        for expected in expected_vals:
306
316
            stanza = read_stanza(tmpf)
307
317
            self.rio_file_stanzas([stanza])
308
 
            self.assertEquals(len(stanza), 1)
 
318
            self.assertEqual(len(stanza), 1)
309
319
            self.assertEqualDiff(stanza.get('s'), expected)
310
320
 
311
321
    def test_write_empty_stanza(self):
312
322
        """Write empty stanza"""
313
323
        l = list(Stanza().to_lines())
314
 
        self.assertEquals(l, [])
 
324
        self.assertEqual(l, [])
315
325
 
316
326
    def test_rio_raises_type_error(self):
317
327
        """TypeError on adding invalid type to Stanza"""
326
336
    def test_rio_unicode(self):
327
337
        uni_data = u'\N{KATAKANA LETTER O}'
328
338
        s = Stanza(foo=uni_data)
329
 
        self.assertEquals(s.get('foo'), uni_data)
 
339
        self.assertEqual(s.get('foo'), uni_data)
330
340
        raw_lines = s.to_lines()
331
 
        self.assertEquals(raw_lines,
 
341
        self.assertEqual(raw_lines,
332
342
                ['foo: ' + uni_data.encode('utf-8') + '\n'])
333
343
        new_s = read_stanza(raw_lines)
334
 
        self.assertEquals(new_s.get('foo'), uni_data)
 
344
        self.assertEqual(new_s.get('foo'), uni_data)
335
345
 
336
346
    def test_rio_to_unicode(self):
337
347
        uni_data = u'\N{KATAKANA LETTER O}'