← 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-02-01 19:13:13 UTC
  • mfrom: (6614.2.2 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20160201191313-wdfvmfff1djde6oq
(vila) Release 2.7.0 (Vincent Ladeuil)

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 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
46
46
        self.assertTrue('number' in s)
47
47
        self.assertFalse('color' in s)
48
48
        self.assertFalse('42' in s)
49
 
        self.assertEquals(list(s.iter_pairs()),
 
49
        self.assertEqual(list(s.iter_pairs()),
50
50
                [('name', 'fred'), ('number', '42')])
51
 
        self.assertEquals(s.get('number'), '42')
52
 
        self.assertEquals(s.get('name'), 'fred')
 
51
        self.assertEqual(s.get('number'), '42')
 
52
        self.assertEqual(s.get('name'), 'fred')
53
53
 
54
54
    def test_value_checks(self):
55
55
        """rio checks types on construction"""
68
68
    def test_to_lines(self):
69
69
        """Write simple rio stanza to string"""
70
70
        s = Stanza(number='42', name='fred')
71
 
        self.assertEquals(list(s.to_lines()),
 
71
        self.assertEqual(list(s.to_lines()),
72
72
                ['name: fred\n',
73
73
                 'number: 42\n'])
74
74
 
76
76
        """Convert rio Stanza to dictionary"""
77
77
        s = Stanza(number='42', name='fred')
78
78
        sd = s.as_dict()
79
 
        self.assertEquals(sd, dict(number='42', name='fred'))
 
79
        self.assertEqual(sd, dict(number='42', name='fred'))
80
80
 
81
81
    def test_to_file(self):
82
82
        """Write rio to file"""
102
102
''')
103
103
        tmpf.seek(0)
104
104
        s2 = read_stanza(tmpf)
105
 
        self.assertEquals(s, s2)
 
105
        self.assertEqual(s, s2)
106
106
 
107
107
    def test_read_stanza(self):
108
108
        """Load stanza from string"""
115
115
        s = read_stanza(lines)
116
116
        self.assertTrue('revision' in s)
117
117
        self.assertEqualDiff(s.get('revision'), 'mbp@sourcefrog.net-123-abc')
118
 
        self.assertEquals(list(s.iter_pairs()),
 
118
        self.assertEqual(list(s.iter_pairs()),
119
119
                [('revision', 'mbp@sourcefrog.net-123-abc'),
120
120
                 ('timestamp', '1130653962'),
121
121
                 ('timezone', '36000'),
122
122
                 ('committer', "Martin Pool <mbp@test.sourcefrog.net>")])
123
 
        self.assertEquals(len(s), 4)
 
123
        self.assertEqual(len(s), 4)
124
124
 
125
125
    def test_repeated_field(self):
126
126
        """Repeated field in rio"""
129
129
                     ('a', '1000'), ('b', '2000')]:
130
130
            s.add(k, v)
131
131
        s2 = read_stanza(s.to_lines())
132
 
        self.assertEquals(s, s2)
133
 
        self.assertEquals(s.get_all('a'), map(str, [10, 100, 1000]))
134
 
        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]))
135
135
 
136
136
    def test_backslash(self):
137
137
        s = Stanza(q='\\')
138
138
        t = s.to_string()
139
139
        self.assertEqualDiff(t, 'q: \\\n')
140
140
        s2 = read_stanza(s.to_lines())
141
 
        self.assertEquals(s, s2)
 
141
        self.assertEqual(s, s2)
142
142
 
143
143
    def test_blank_line(self):
144
144
        s = Stanza(none='', one='\n', two='\n\n')
151
151
\t
152
152
""")
153
153
        s2 = read_stanza(s.to_lines())
154
 
        self.assertEquals(s, s2)
 
154
        self.assertEqual(s, s2)
155
155
 
156
156
    def test_whitespace_value(self):
157
157
        s = Stanza(space=' ', tabs='\t\t\t', combo='\n\t\t\n')
163
163
tabs: \t\t\t
164
164
""")
165
165
        s2 = read_stanza(s.to_lines())
166
 
        self.assertEquals(s, s2)
 
166
        self.assertEqual(s, s2)
167
167
        self.rio_file_stanzas([s])
168
168
 
169
169
    def test_quoted(self):
179
179
                   q9='\\"\\"',
180
180
                   )
181
181
        s2 = read_stanza(s.to_lines())
182
 
        self.assertEquals(s, s2)
 
182
        self.assertEqual(s, s2)
183
183
        # apparent bug in read_stanza
184
184
        # s3 = read_stanza(self.stanzas_to_str([s]))
185
 
        # self.assertEquals(s, s3)
 
185
        # self.assertEqual(s, s3)
186
186
 
187
187
    def test_read_empty(self):
188
188
        """Detect end of rio file"""
238
238
""")
239
239
        tmpf.seek(0)
240
240
        s = read_stanza(tmpf)
241
 
        self.assertEquals(s, Stanza(version_header='1'))
 
241
        self.assertEqual(s, Stanza(version_header='1'))
242
242
        s = read_stanza(tmpf)
243
 
        self.assertEquals(s, Stanza(name="foo", val='123'))
 
243
        self.assertEqual(s, Stanza(name="foo", val='123'))
244
244
        s = read_stanza(tmpf)
245
245
        self.assertEqualDiff(s.get('name'), 'quoted')
246
246
        self.assertEqualDiff(s.get('address'), '  "Willowglen"\n  42 Wallaby Way\n  Sydney')
247
247
        s = read_stanza(tmpf)
248
 
        self.assertEquals(s, Stanza(name="bar", val='129319'))
 
248
        self.assertEqual(s, Stanza(name="bar", val='129319'))
249
249
        s = read_stanza(tmpf)
250
 
        self.assertEquals(s, None)
 
250
        self.assertEqual(s, None)
251
251
        self.check_rio_file(tmpf)
252
252
 
253
253
    def check_rio_file(self, real_file):
254
254
        real_file.seek(0)
255
255
        read_write = rio_file(RioReader(real_file)).read()
256
256
        real_file.seek(0)
257
 
        self.assertEquals(read_write, real_file.read())
 
257
        self.assertEqual(read_write, real_file.read())
258
258
 
259
259
    @staticmethod
260
260
    def stanzas_to_str(stanzas):
315
315
        for expected in expected_vals:
316
316
            stanza = read_stanza(tmpf)
317
317
            self.rio_file_stanzas([stanza])
318
 
            self.assertEquals(len(stanza), 1)
 
318
            self.assertEqual(len(stanza), 1)
319
319
            self.assertEqualDiff(stanza.get('s'), expected)
320
320
 
321
321
    def test_write_empty_stanza(self):
322
322
        """Write empty stanza"""
323
323
        l = list(Stanza().to_lines())
324
 
        self.assertEquals(l, [])
 
324
        self.assertEqual(l, [])
325
325
 
326
326
    def test_rio_raises_type_error(self):
327
327
        """TypeError on adding invalid type to Stanza"""
336
336
    def test_rio_unicode(self):
337
337
        uni_data = u'\N{KATAKANA LETTER O}'
338
338
        s = Stanza(foo=uni_data)
339
 
        self.assertEquals(s.get('foo'), uni_data)
 
339
        self.assertEqual(s.get('foo'), uni_data)
340
340
        raw_lines = s.to_lines()
341
 
        self.assertEquals(raw_lines,
 
341
        self.assertEqual(raw_lines,
342
342
                ['foo: ' + uni_data.encode('utf-8') + '\n'])
343
343
        new_s = read_stanza(raw_lines)
344
 
        self.assertEquals(new_s.get('foo'), uni_data)
 
344
        self.assertEqual(new_s.get('foo'), uni_data)
345
345
 
346
346
    def test_rio_to_unicode(self):
347
347
        uni_data = u'\N{KATAKANA LETTER O}'