← 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
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"""
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"""
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')
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')
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):
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"""
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()
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):
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}'