← 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: Canonical.com Patch Queue Manager
  • Date: 2008-09-03 22:30:56 UTC
  • mfrom: (3644.2.13 index_builder_cleanup)
  • Revision ID: pqm@pqm.ubuntu.com-20080903223056-b108iytb38xkznci
(jam) Streamline BTreeBuilder.add_node et al to make btree creation
        faster.

Show diffs side-by-side

added added

removed removed

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