← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_pack.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_pack.py
1
 
# Copyright (C) 2007 Canonical Ltd
 
1
# Copyright (C) 2007, 2009, 2011, 2012, 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 bzrlib.pack."""
18
18
 
42
42
        serialiser = pack.ContainerSerialiser()
43
43
        record = serialiser.bytes_record('bytes', [])
44
44
        self.assertEqual('B5\n\nbytes', record)
45
 
        
 
45
 
46
46
    def test_bytes_record_one_name_with_one_part(self):
47
47
        serialiser = pack.ContainerSerialiser()
48
48
        record = serialiser.bytes_record('bytes', [('name',)])
49
49
        self.assertEqual('B5\nname\n\nbytes', record)
50
 
        
 
50
 
51
51
    def test_bytes_record_one_name_with_two_parts(self):
52
52
        serialiser = pack.ContainerSerialiser()
53
53
        record = serialiser.bytes_record('bytes', [('part1', 'part2')])
54
54
        self.assertEqual('B5\npart1\x00part2\n\nbytes', record)
55
 
        
 
55
 
56
56
    def test_bytes_record_two_names(self):
57
57
        serialiser = pack.ContainerSerialiser()
58
58
        record = serialiser.bytes_record('bytes', [('name1',), ('name2',)])
64
64
            errors.InvalidRecordError,
65
65
            serialiser.bytes_record, 'bytes', [('bad name',)])
66
66
 
 
67
    def test_bytes_record_header(self):
 
68
        serialiser = pack.ContainerSerialiser()
 
69
        record = serialiser.bytes_header(32, [('name1',), ('name2',)])
 
70
        self.assertEqual('B32\nname1\nname2\n\n', record)
 
71
 
67
72
 
68
73
class TestContainerWriter(tests.TestCase):
69
74
 
70
75
    def setUp(self):
 
76
        super(TestContainerWriter, self).setUp()
71
77
        self.output = StringIO()
72
78
        self.writer = pack.ContainerWriter(self.output.write)
73
79
 
79
85
 
80
86
    def test_construct(self):
81
87
        """Test constructing a ContainerWriter.
82
 
        
 
88
 
83
89
        This uses None as the output stream to show that the constructor
84
90
        doesn't try to use the output stream.
85
91
        """
125
131
    def test_add_bytes_record_one_name(self):
126
132
        """Add a bytes record with one name."""
127
133
        self.writer.begin()
 
134
 
128
135
        offset, length = self.writer.add_bytes_record(
129
136
            'abc', names=[('name1', )])
130
137
        self.assertEqual((42, 13), (offset, length))
132
139
            'Bazaar pack format 1 (introduced in 0.18)\n'
133
140
            'B3\nname1\n\nabc')
134
141
 
 
142
    def test_add_bytes_record_split_writes(self):
 
143
        """Write a large record which does multiple IOs"""
 
144
 
 
145
        writes = []
 
146
        real_write = self.writer.write_func
 
147
 
 
148
        def record_writes(bytes):
 
149
            writes.append(bytes)
 
150
            return real_write(bytes)
 
151
 
 
152
        self.writer.write_func = record_writes
 
153
        self.writer._JOIN_WRITES_THRESHOLD = 2
 
154
 
 
155
        self.writer.begin()
 
156
        offset, length = self.writer.add_bytes_record(
 
157
            'abcabc', names=[('name1', )])
 
158
        self.assertEqual((42, 16), (offset, length))
 
159
        self.assertOutput(
 
160
            'Bazaar pack format 1 (introduced in 0.18)\n'
 
161
            'B6\nname1\n\nabcabc')
 
162
 
 
163
        self.assertEqual([
 
164
            'Bazaar pack format 1 (introduced in 0.18)\n',
 
165
            'B6\nname1\n\n',
 
166
            'abcabc'],
 
167
            writes)
 
168
 
135
169
    def test_add_bytes_record_two_names(self):
136
170
        """Add a bytes record with two names."""
137
171
        self.writer.begin()
205
239
 
206
240
    def test_construct(self):
207
241
        """Test constructing a ContainerReader.
208
 
        
209
 
        This uses None as the output stream to show that the constructor doesn't
210
 
        try to use the input stream.
 
242
 
 
243
        This uses None as the output stream to show that the constructor
 
244
        doesn't try to use the input stream.
211
245
        """
212
246
        reader = pack.ContainerReader(None)
213
247
 
243
277
 
244
278
    def test_container_with_one_unnamed_record(self):
245
279
        """Read a container with one Bytes record.
246
 
        
 
280
 
247
281
        Parsing Bytes records is more thoroughly exercised by
248
282
        TestBytesRecordReader.  This test is here to ensure that
249
283
        ContainerReader's integration with BytesRecordReader is working.
258
292
 
259
293
    def test_validate_empty_container(self):
260
294
        """validate does not raise an error for a container with no records."""
261
 
        reader = self.get_reader_for("Bazaar pack format 1 (introduced in 0.18)\nE")
 
295
        reader = self.get_reader_for(
 
296
            "Bazaar pack format 1 (introduced in 0.18)\nE")
262
297
        # No exception raised
263
298
        reader.validate()
264
299
 
326
361
        reader = self.get_reader_for(
327
362
            "Bazaar pack format 1 (introduced in 0.18)\nB0\n\xcc\n\nE")
328
363
        self.assertRaises(errors.InvalidRecordError, reader.validate)
329
 
        
 
364
 
330
365
 
331
366
class TestBytesRecordReader(tests.TestCase):
332
367
    """Tests for reading and validating Bytes records with
333
368
    BytesRecordReader.
334
 
    
 
369
 
335
370
    Like TestContainerReader, this explicitly tests the reading of format 1
336
371
    data.  If a new version of the format is added, then a separate set of
337
372
    tests for reading that format should be added.
385
420
    def test_early_eof(self):
386
421
        """Tests for premature EOF occuring during parsing Bytes records with
387
422
        BytesRecordReader.
388
 
        
 
423
 
389
424
        A incomplete container might be interrupted at any point.  The
390
425
        BytesRecordReader needs to cope with the input stream running out no
391
426
        matter where it is in the parsing process.
518
553
    """Tests of the ReadVFile class.
519
554
 
520
555
    Error cases are deliberately undefined: this code adapts the underlying
521
 
    transport interface to a single 'streaming read' interface as 
 
556
    transport interface to a single 'streaming read' interface as
522
557
    ContainerReader needs.
523
558
    """
524
559
 
584
619
        parsed_records = parser.read_pending_records()
585
620
        self.assertEqual([expected_record], parsed_records)
586
621
 
587
 
        
 
622
 
588
623
class TestContainerPushParser(PushParserTestCase):
589
624
    """Tests for ContainerPushParser.
590
 
    
 
625
 
591
626
    The ContainerPushParser reads format 1 containers, so these tests
592
627
    explicitly test how it reacts to format 1 data.  If a new version of the
593
628
    format is added, then separate tests for that format should be added.
609
644
            [([('name1',)], 'body1'), ([('name2',)], 'body2')],
610
645
            parser.read_pending_records())
611
646
 
 
647
    def test_multiple_empty_records_at_once(self):
 
648
        """If multiple empty records worth of data are fed to the parser in one
 
649
        string, the parser will correctly parse all the records.
 
650
 
 
651
        (A naive implementation might stop after parsing the first empty
 
652
        record, because the buffer size had not changed.)
 
653
        """
 
654
        parser = self.make_parser_expecting_record_type()
 
655
        parser.accept_bytes("B0\nname1\n\nB0\nname2\n\n")
 
656
        self.assertEqual(
 
657
            [([('name1',)], ''), ([('name2',)], '')],
 
658
            parser.read_pending_records())
 
659
 
612
660
 
613
661
class TestContainerPushParserBytesParsing(PushParserTestCase):
614
662
    """Tests for reading Bytes records with ContainerPushParser.
615
 
    
 
663
 
616
664
    The ContainerPushParser reads format 1 containers, so these tests
617
665
    explicitly test how it reacts to format 1 data.  If a new version of the
618
666
    format is added, then separate tests for that format should be added.
691
739
        parser.accept_bytes("6\n\nabcdef")
692
740
        self.assertEqual([([], 'abcdef')], parser.read_pending_records())
693
741
        self.assertEqual([], parser.read_pending_records())
694
 
 
695