1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
|
# Copyright (C) 2005 by Canonical Ltd
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
"""Tests for basic_io serialization
A simple, reproducible structured IO format.
basic_io itself works in Unicode strings. It is typically encoded to UTF-8,
but this depends on the transport.
"""
import os
import sys
from tempfile import TemporaryFile
from bzrlib.tests import TestCaseInTempDir, TestCase
from bzrlib.basicio import BasicWriter, Stanza, read_stanza, read_stanzas
class TestBasicIO(TestCase):
def test_stanza(self):
"""Construct basic_io stanza in memory"""
s = Stanza(number=42, name="fred")
self.assertTrue('number' in s)
self.assertFalse('color' in s)
self.assertFalse(42 in s)
self.assertEquals(list(s.iter_pairs()),
[('name', 'fred'), ('number', 42)])
self.assertEquals(s.get('number'), 42)
self.assertEquals(s.get('name'), 'fred')
def test_value_checks(self):
"""basic_io checks types on construction"""
# these aren't enforced at construction time
## self.assertRaises(ValueError,
## Stanza, complex=42 + 3j)
## self.assertRaises(ValueError,
## Stanza, several=range(10))
def test_to_lines(self):
"""Write simple basic_io stanza to string"""
s = Stanza(number=42, name='fred')
self.assertEquals(list(s.to_lines()),
[' name "fred"\n',
'number 42\n'])
def test_to_file(self):
"""Write basic_io to file"""
tmpf = TemporaryFile()
s = Stanza(a_thing='something with "quotes like \\"this\\""', number=42, name='fred')
s.write(tmpf)
tmpf.seek(0)
self.assertEqualDiff(tmpf.read(), r'''
a_thing "something with \"quotes like \\\"this\\\"\""
name "fred"
number 42
'''[1:])
def test_multiline_string(self):
"""Write basic_io with multiline string"""
tmpf = TemporaryFile()
s = Stanza(a=123, motto="war is peace\nfreedom is slavery\nignorance is strength\n",
charlie_horse=456)
s.write(tmpf)
tmp.seek(0)
self.assertEqualDiff(tmpf.read(), r'''\
a 123
motto "war is peace
freedom is slavery
ignorance is strength
"
charlie_horse 456
''')
def test_multiline_string(self):
tmpf = TemporaryFile()
s = Stanza(motto="war is peace\nfreedom is slavery\nignorance is strength")
s.write(tmpf)
tmpf.seek(0)
self.assertEqualDiff(tmpf.read(), '''\
motto "war is peace
freedom is slavery
ignorance is strength"
''')
tmpf.seek(0)
s2 = read_stanza(tmpf)
self.assertEquals(s, s2)
def test_read_stanza(self):
"""Load stanza from string"""
lines = """\
revision "mbp@sourcefrog.net-123-abc"
timestamp 1130653962
timezone 36000
committer "Martin Pool <mbp@test.sourcefrog.net>"
""".splitlines(True)
s = read_stanza(lines)
self.assertTrue('revision' in s)
self.assertEqualDiff(s.get('revision'), 'mbp@sourcefrog.net-123-abc')
self.assertEquals(list(s.iter_pairs()),
[('revision', 'mbp@sourcefrog.net-123-abc'),
('timestamp', 1130653962),
('timezone', 36000),
('committer', "Martin Pool <mbp@test.sourcefrog.net>")])
self.assertEquals(len(s), 4)
def test_repeated_field(self):
"""Repeated field in basic_io"""
s = Stanza()
for k, v in [('a', 10), ('b', 20), ('a', 100), ('b', 200), ('a', 1000), ('b', 2000)]:
s.add(k, v)
s2 = read_stanza(s.to_lines())
self.assertEquals(s, s2)
self.assertEquals(s.get_all('a'), [10, 100, 1000])
self.assertEquals(s.get_all('b'), [20, 200, 2000])
def test_longint(self):
"""basic_io packing long integers"""
s = Stanza(x=-12345678901234567890,
y=1<<100)
lines = s.to_lines()
s2 = read_stanza(lines)
self.assertEquals(s, s2)
def test_quoted_0(self):
"""Backslash quoted cases"""
s = Stanza(q='\\')
t = s.to_string()
self.assertEqualDiff(t, 'q "\\\\"\n')
s2 = read_stanza(s.to_lines())
self.assertEquals(s, s2)
def test_quoted_1(self):
"""Backslash quoted cases"""
s = Stanza(q=r'\"\"')
self.assertEqualDiff(s.to_string(), r'q "\\\"\\\""' + '\n')
def test_quoted_4(self):
s = Stanza(q=r'""""')
t = s.to_string()
self.assertEqualDiff(t, r'q "\"\"\"\""' + '\n')
s2 = read_stanza(s.to_lines())
self.assertEquals(s, s2)
def test_quoted_5(self):
s = Stanza(q=r'\\\\\"')
t = s.to_string()
s2 = read_stanza(s.to_lines())
self.assertEquals(s, s2)
def test_quoted_6(self):
qval = r'''
"
\"
'''
s = Stanza(q=qval)
t = s.to_string()
self.log(t)
s2 = read_stanza(s.to_lines())
self.assertEquals(s2['q'], qval)
def test_quoted_7(self):
qval = r'''
"
\"
\\"
trailing stuff'''
s = Stanza(q=qval)
t = s.to_string()
self.log(t)
s2 = read_stanza(s.to_lines())
self.assertEquals(s2['q'], qval)
def test_quoted_8(self):
qval = r'''trailing
quote"'''
s = Stanza(q=qval)
t = s.to_string()
self.log(t)
s2 = read_stanza(s.to_lines())
self.assertEquals(s2['q'], qval)
def test_quoted(self):
"""basic_io quoted string cases"""
s = Stanza(q1='"hello"',
q2=' "for',
q3='\n\n"for"\n',
q4='for\n"\nfor',
q5='\n',
q6='"',
q7='""',
q8='\\',
q9='\\"\\"',
)
s2 = read_stanza(s.to_lines())
self.assertEquals(s, s2)
def test_read_empty(self):
"""Detect end of basic_io file"""
s = read_stanza([])
self.assertEqual(s, None)
self.assertTrue(s is None)
def test_read_iter(self):
"""Read several stanzas from file"""
tmpf = TemporaryFile()
tmpf.write("""\
version_header 1
name "foo"
val 123
name "bar"
val 129319
""")
tmpf.seek(0)
reader = read_stanzas(tmpf)
read_iter = iter(reader)
stuff = list(reader)
self.assertEqual(stuff,
[ Stanza(version_header=1),
Stanza(name="foo", val=123),
Stanza(name="bar", val=129319), ])
def test_read_several(self):
"""Read several stanzas from file"""
tmpf = TemporaryFile()
tmpf.write("""\
version_header 1
name "foo"
val 123
name "quoted"
address " \\"Willowglen\\"
42 Wallaby Way
Sydney"
name "bar"
val 129319
""")
tmpf.seek(0)
s = read_stanza(tmpf)
self.assertEquals(s, Stanza(version_header=1))
s = read_stanza(tmpf)
self.assertEquals(s, Stanza(name="foo", val=123))
s = read_stanza(tmpf)
self.assertEqualDiff(s.get('name'), 'quoted')
self.assertEqualDiff(s.get('address'), ' "Willowglen"\n 42 Wallaby Way\n Sydney')
s = read_stanza(tmpf)
self.assertEquals(s, Stanza(name="bar", val=129319))
s = read_stanza(tmpf)
self.assertEquals(s, None)
def test_tricky_quoted(self):
tmpf = TemporaryFile()
tmpf.write(r"""
s "\"one\""
s "
\"one\"
"
s "\""
s "\"\""
s "\"\"\""
s "
"
s "\\"
s "
\\
\\\\
"
s "word\\"
s "quote\""
s "backslashes\\\\\\"
s "both\\\""
"""[1:]) # remove initial newline
tmpf.seek(0)
expected_vals = ['"one"',
'\n"one"\n',
'"',
'""',
'"""',
'\n',
'\\',
'\n\\\n\\\\\n',
'word\\',
'quote\"',
'backslashes\\\\\\',
'both\\\"',
]
for expected in expected_vals:
stanza = read_stanza(tmpf)
self.assertEquals(len(stanza), 1)
self.assertEqualDiff(stanza.get('s'), expected)
def test_write_bool(self):
"""Write bool to basic_io"""
l = list(Stanza(my_bool=True).to_lines())
self.assertEquals(l, ['my_bool 1\n'])
def test_write_empty_stanza(self):
"""Write empty stanza"""
l = list(Stanza().to_lines())
self.assertEquals(l, [])
|