← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_patches.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_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,
 
36
                            iter_patched_from_hunks,
34
37
                            parse_line,
35
38
                            parse_patch,
36
 
                            parse_patches)
 
39
                            parse_patches,
 
40
                            NO_NL)
37
41
 
38
42
 
39
43
class PatchesTester(TestCase):
40
44
 
41
45
    def datafile(self, filename):
42
 
        data_path = os.path.join(os.path.dirname(__file__), 
 
46
        data_path = os.path.join(os.path.dirname(__file__),
43
47
                                 "test_patches_data", filename)
44
48
        return file(data_path, "rb")
45
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
 
 
65
    def test_preserve_dirty_head(self):
 
66
        """Parse a patch containing a dirty header, and preserve lines"""
 
67
        lines = ["=== added directory 'foo/bar'\n",
 
68
                 "=== modified file 'orig/commands.py'\n",
 
69
                 "--- orig/commands.py\n",
 
70
                 "+++ mod/dommands.py\n",
 
71
                 "=== modified file 'orig/another.py'\n",
 
72
                 "--- orig/another.py\n",
 
73
                 "+++ mod/another.py\n"]
 
74
        patches = parse_patches(
 
75
            lines.__iter__(), allow_dirty=True, keep_dirty=True)
 
76
        self.assertLength(2, patches)
 
77
        self.assertEqual(patches[0]['dirty_head'],
 
78
                         ["=== added directory 'foo/bar'\n",
 
79
                          "=== modified file 'orig/commands.py'\n"])
 
80
        self.assertEqual(patches[0]['patch'].get_header().splitlines(True),
 
81
                         ["--- orig/commands.py\n", "+++ mod/dommands.py\n"])
 
82
        self.assertEqual(patches[1]['dirty_head'],
 
83
                         ["=== modified file 'orig/another.py'\n"])
 
84
        self.assertEqual(patches[1]['patch'].get_header().splitlines(True),
 
85
                         ["--- orig/another.py\n", "+++ mod/another.py\n"])
 
86
 
46
87
    def testValidPatchHeader(self):
47
88
        """Parse a valid patch header"""
48
89
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
59
100
    def testValidHunkHeader(self):
60
101
        """Parse a valid hunk header"""
61
102
        header = "@@ -34,11 +50,6 @@\n"
62
 
        hunk = hunk_from_header(header);
 
103
        hunk = hunk_from_header(header)
63
104
        self.assertEqual(hunk.orig_pos, 34)
64
105
        self.assertEqual(hunk.orig_range, 11)
65
106
        self.assertEqual(hunk.mod_pos, 50)
69
110
    def testValidHunkHeader2(self):
70
111
        """Parse a tricky, valid hunk header"""
71
112
        header = "@@ -1 +0,0 @@\n"
72
 
        hunk = hunk_from_header(header);
 
113
        hunk = hunk_from_header(header)
73
114
        self.assertEqual(hunk.orig_pos, 1)
74
115
        self.assertEqual(hunk.orig_range, 1)
75
116
        self.assertEqual(hunk.mod_pos, 0)
98
139
        self.makeMalformed("@@ -34,11 +50,6.5 @@\n")
99
140
        self.makeMalformed("@@ -34,11 +50,-6 @@\n")
100
141
 
101
 
    def lineThing(self,text, type):
 
142
    def lineThing(self, text, type):
102
143
        line = parse_line(text)
103
144
        self.assertIsInstance(line, type)
104
145
        self.assertEqual(str(line), text)
111
152
        self.lineThing(" hello\n", ContextLine)
112
153
        self.lineThing("+hello\n", InsertLine)
113
154
        self.lineThing("-hello\n", RemoveLine)
114
 
    
 
155
 
115
156
    def testMalformedLine(self):
116
157
        """Parse invalid valid hunk lines"""
117
158
        self.makeMalformedLine("hello\n")
118
 
    
 
159
 
 
160
    def testMalformedLineNO_NL(self):
 
161
        """Parse invalid '\ No newline at end of file' in hunk lines"""
 
162
        self.makeMalformedLine(NO_NL)
 
163
 
119
164
    def compare_parsed(self, patchtext):
120
165
        lines = patchtext.splitlines(True)
121
166
        patch = parse_patch(lines.__iter__())
123
168
        i = difference_index(patchtext, pstr)
124
169
        if i is not None:
125
170
            print "%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i])
126
 
        self.assertEqual (patchtext, str(patch))
 
171
        self.assertEqual(patchtext, str(patch))
127
172
 
128
173
    def testAll(self):
129
174
        """Test parsing a whole patch"""
130
175
        patchtext = self.datafile("patchtext.patch").read()
131
176
        self.compare_parsed(patchtext)
132
177
 
 
178
    def test_parse_binary(self):
 
179
        """Test parsing a whole patch"""
 
180
        patches = parse_patches(self.data_lines("binary.patch"))
 
181
        self.assertIs(BinaryPatch, patches[0].__class__)
 
182
        self.assertIs(Patch, patches[1].__class__)
 
183
        self.assertContainsRe(patches[0].oldname, '^bar\t')
 
184
        self.assertContainsRe(patches[0].newname, '^qux\t')
 
185
        self.assertContainsRe(str(patches[0]),
 
186
                              'Binary files bar\t.* and qux\t.* differ\n')
 
187
 
 
188
    def test_parse_binary_after_normal(self):
 
189
        patches = parse_patches(self.data_lines("binary-after-normal.patch"))
 
190
        self.assertIs(BinaryPatch, patches[1].__class__)
 
191
        self.assertIs(Patch, patches[0].__class__)
 
192
        self.assertContainsRe(patches[1].oldname, '^bar\t')
 
193
        self.assertContainsRe(patches[1].newname, '^qux\t')
 
194
        self.assertContainsRe(str(patches[1]),
 
195
                              'Binary files bar\t.* and qux\t.* differ\n')
 
196
 
 
197
    def test_roundtrip_binary(self):
 
198
        patchtext = ''.join(self.data_lines("binary.patch"))
 
199
        patches = parse_patches(patchtext.splitlines(True))
 
200
        self.assertEqual(patchtext, ''.join(str(p) for p in patches))
 
201
 
133
202
    def testInit(self):
134
203
        """Handle patches missing half the position, range tuple"""
135
204
        patchtext = \
173
242
            ('diff-4', 'orig-4', 'mod-4'),
174
243
            ('diff-5', 'orig-5', 'mod-5'),
175
244
            ('diff-6', 'orig-6', 'mod-6'),
 
245
            ('diff-7', 'orig-7', 'mod-7'),
176
246
        ]
177
247
        for diff, orig, mod in files:
178
248
            patch = self.datafile(diff)
180
250
            mod_lines = list(self.datafile(mod))
181
251
 
182
252
            patched_file = IterableFile(iter_patched(orig_lines, patch))
183
 
            lines = []
 
253
            count = 0
 
254
            for patch_line in patched_file:
 
255
                self.assertEqual(patch_line, mod_lines[count])
 
256
                count += 1
 
257
            self.assertEqual(count, len(mod_lines))
 
258
 
 
259
    def test_iter_patched_binary(self):
 
260
        binary_lines = self.data_lines('binary.patch')
 
261
        e = self.assertRaises(BinaryFiles, iter_patched, [], binary_lines)
 
262
 
 
263
    def test_iter_patched_from_hunks(self):
 
264
        """Test a few patch files, and make sure they work."""
 
265
        files = [
 
266
            ('diff-2', 'orig-2', 'mod-2'),
 
267
            ('diff-3', 'orig-3', 'mod-3'),
 
268
            ('diff-4', 'orig-4', 'mod-4'),
 
269
            ('diff-5', 'orig-5', 'mod-5'),
 
270
            ('diff-6', 'orig-6', 'mod-6'),
 
271
            ('diff-7', 'orig-7', 'mod-7'),
 
272
        ]
 
273
        for diff, orig, mod in files:
 
274
            parsed = parse_patch(self.datafile(diff))
 
275
            orig_lines = list(self.datafile(orig))
 
276
            mod_lines = list(self.datafile(mod))
 
277
            iter_patched = iter_patched_from_hunks(orig_lines, parsed.hunks)
 
278
            patched_file = IterableFile(iter_patched)
184
279
            count = 0
185
280
            for patch_line in patched_file:
186
281
                self.assertEqual(patch_line, mod_lines[count])
227
322
        for patch in patches:
228
323
            patch_files.append((patch.oldname, patch.newname))
229
324
        self.assertEqual(patch_files, filenames)
 
325
 
 
326
    def testStatsValues(self):
 
327
        """Test the added, removed and hunks values for stats_values."""
 
328
        patch = parse_patch(self.datafile("diff"))
 
329
        self.assertEqual((299, 407, 48), patch.stats_values())