← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_patches.py

(jameinel) Allow 'bzr serve' to interpret SIGHUP as a graceful shutdown.
 (bug #795025) (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_patches.py
1
 
# Copyright (C) 2004 - 2008 Aaron Bentley, Canonical Ltd
2
 
# <aaron.bentley@utoronto.ca>
 
1
# Copyright (C) 2005-2010 Aaron Bentley, Canonical Ltd
3
2
#
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
13
12
#
14
13
# You should have received a copy of the GNU General Public License
15
14
# along with this program; if not, write to the Free Software
16
 
# 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
17
16
 
18
17
 
19
18
import os.path
21
20
from bzrlib.tests import TestCase
22
21
 
23
22
from bzrlib.iterablefile import IterableFile
24
 
from bzrlib.patches import (MalformedLine, 
25
 
                            MalformedHunkHeader, 
26
 
                            MalformedPatchHeader, 
27
 
                            ContextLine, 
 
23
from bzrlib.patches import (MalformedLine,
 
24
                            MalformedHunkHeader,
 
25
                            MalformedPatchHeader,
 
26
                            BinaryPatch,
 
27
                            BinaryFiles,
 
28
                            Patch,
 
29
                            ContextLine,
28
30
                            InsertLine,
29
 
                            RemoveLine, 
30
 
                            difference_index, 
 
31
                            RemoveLine,
 
32
                            difference_index,
31
33
                            get_patch_names,
32
 
                            hunk_from_header, 
33
 
                            iter_patched, 
 
34
                            hunk_from_header,
 
35
                            iter_patched,
34
36
                            iter_patched_from_hunks,
35
37
                            parse_line,
36
38
                            parse_patch,
37
 
                            parse_patches)
 
39
                            parse_patches,
 
40
                            NO_NL)
38
41
 
39
42
 
40
43
class PatchesTester(TestCase):
41
44
 
42
45
    def datafile(self, filename):
43
 
        data_path = os.path.join(os.path.dirname(__file__), 
 
46
        data_path = os.path.join(os.path.dirname(__file__),
44
47
                                 "test_patches_data", filename)
45
48
        return file(data_path, "rb")
46
49
 
 
50
    def data_lines(self, filename):
 
51
        datafile = self.datafile(filename)
 
52
        try:
 
53
            return datafile.readlines()
 
54
        finally:
 
55
            datafile.close()
 
56
 
 
57
    def test_parse_patches_leading_noise(self):
 
58
        # https://bugs.launchpad.net/bzr/+bug/502076
 
59
        # https://code.launchpad.net/~toshio/bzr/allow-dirty-patches/+merge/18854
 
60
        lines = ["diff -pruN commands.py",
 
61
            "--- orig/commands.py",
 
62
            "+++ mod/dommands.py"]
 
63
        bits = parse_patches(iter(lines), allow_dirty=True)
 
64
 
47
65
    def testValidPatchHeader(self):
48
66
        """Parse a valid patch header"""
49
67
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
112
130
        self.lineThing(" hello\n", ContextLine)
113
131
        self.lineThing("+hello\n", InsertLine)
114
132
        self.lineThing("-hello\n", RemoveLine)
115
 
    
 
133
 
116
134
    def testMalformedLine(self):
117
135
        """Parse invalid valid hunk lines"""
118
136
        self.makeMalformedLine("hello\n")
119
 
    
 
137
 
 
138
    def testMalformedLineNO_NL(self):
 
139
        """Parse invalid '\ No newline at end of file' in hunk lines"""
 
140
        self.makeMalformedLine(NO_NL)
 
141
 
120
142
    def compare_parsed(self, patchtext):
121
143
        lines = patchtext.splitlines(True)
122
144
        patch = parse_patch(lines.__iter__())
131
153
        patchtext = self.datafile("patchtext.patch").read()
132
154
        self.compare_parsed(patchtext)
133
155
 
 
156
    def test_parse_binary(self):
 
157
        """Test parsing a whole patch"""
 
158
        patches = parse_patches(self.data_lines("binary.patch"))
 
159
        self.assertIs(BinaryPatch, patches[0].__class__)
 
160
        self.assertIs(Patch, patches[1].__class__)
 
161
        self.assertContainsRe(patches[0].oldname, '^bar\t')
 
162
        self.assertContainsRe(patches[0].newname, '^qux\t')
 
163
        self.assertContainsRe(str(patches[0]),
 
164
                                  'Binary files bar\t.* and qux\t.* differ\n')
 
165
 
 
166
    def test_parse_binary_after_normal(self):
 
167
        patches = parse_patches(self.data_lines("binary-after-normal.patch"))
 
168
        self.assertIs(BinaryPatch, patches[1].__class__)
 
169
        self.assertIs(Patch, patches[0].__class__)
 
170
        self.assertContainsRe(patches[1].oldname, '^bar\t')
 
171
        self.assertContainsRe(patches[1].newname, '^qux\t')
 
172
        self.assertContainsRe(str(patches[1]),
 
173
                                  'Binary files bar\t.* and qux\t.* differ\n')
 
174
 
 
175
    def test_roundtrip_binary(self):
 
176
        patchtext = ''.join(self.data_lines("binary.patch"))
 
177
        patches = parse_patches(patchtext.splitlines(True))
 
178
        self.assertEqual(patchtext, ''.join(str(p) for p in patches))
 
179
 
134
180
    def testInit(self):
135
181
        """Handle patches missing half the position, range tuple"""
136
182
        patchtext = \
174
220
            ('diff-4', 'orig-4', 'mod-4'),
175
221
            ('diff-5', 'orig-5', 'mod-5'),
176
222
            ('diff-6', 'orig-6', 'mod-6'),
 
223
            ('diff-7', 'orig-7', 'mod-7'),
177
224
        ]
178
225
        for diff, orig, mod in files:
179
226
            patch = self.datafile(diff)
188
235
                count += 1
189
236
            self.assertEqual(count, len(mod_lines))
190
237
 
 
238
    def test_iter_patched_binary(self):
 
239
        binary_lines = self.data_lines('binary.patch')
 
240
        e = self.assertRaises(BinaryFiles, iter_patched, [], binary_lines)
 
241
 
 
242
 
191
243
    def test_iter_patched_from_hunks(self):
192
244
        """Test a few patch files, and make sure they work."""
193
245
        files = [
196
248
            ('diff-4', 'orig-4', 'mod-4'),
197
249
            ('diff-5', 'orig-5', 'mod-5'),
198
250
            ('diff-6', 'orig-6', 'mod-6'),
 
251
            ('diff-7', 'orig-7', 'mod-7'),
199
252
        ]
200
253
        for diff, orig, mod in files:
201
254
            parsed = parse_patch(self.datafile(diff))