← 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: Jelmer Vernooij
  • Date: 2015-11-15 02:30:05 UTC
  • mto: This revision was merged to the branch mainline in revision 6609.
  • Revision ID: jelmer@jelmer.uk-20151115023005-fcfi763b5eu1ne2o
Fix auodoc_rstx when running with LANG=C.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_patches.py
1
 
# Copyright (C) 2004 - 2006 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
17
 
 
18
 
 
19
 
import unittest
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
20
18
import os.path
21
19
 
 
20
from bzrlib.tests import TestCase
 
21
 
22
22
from bzrlib.iterablefile import IterableFile
23
 
from bzrlib.patches import (MalformedLine, 
24
 
                            MalformedHunkHeader, 
25
 
                            MalformedPatchHeader, 
26
 
                            ContextLine, 
 
23
from bzrlib.patches import (MalformedLine,
 
24
                            MalformedHunkHeader,
 
25
                            MalformedPatchHeader,
 
26
                            BinaryPatch,
 
27
                            BinaryFiles,
 
28
                            Patch,
 
29
                            ContextLine,
27
30
                            InsertLine,
28
 
                            RemoveLine, 
29
 
                            difference_index, 
 
31
                            RemoveLine,
 
32
                            difference_index,
30
33
                            get_patch_names,
31
 
                            hunk_from_header, 
32
 
                            iter_patched, 
 
34
                            hunk_from_header,
 
35
                            iter_patched,
 
36
                            iter_patched_from_hunks,
33
37
                            parse_line,
34
 
                            parse_patch)
35
 
 
36
 
 
37
 
class PatchesTester(unittest.TestCase):
 
38
                            parse_patch,
 
39
                            parse_patches,
 
40
                            NO_NL)
 
41
 
 
42
 
 
43
class PatchesTester(TestCase):
 
44
 
38
45
    def datafile(self, filename):
39
 
        data_path = os.path.join(os.path.dirname(__file__), 
 
46
        data_path = os.path.join(os.path.dirname(__file__),
40
47
                                 "test_patches_data", filename)
41
48
        return file(data_path, "rb")
42
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
 
43
87
    def testValidPatchHeader(self):
44
88
        """Parse a valid patch header"""
45
89
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
46
90
        (orig, mod) = get_patch_names(lines.__iter__())
47
 
        assert(orig == "orig/commands.py")
48
 
        assert(mod == "mod/dommands.py")
 
91
        self.assertEqual(orig, "orig/commands.py")
 
92
        self.assertEqual(mod, "mod/dommands.py")
49
93
 
50
94
    def testInvalidPatchHeader(self):
51
95
        """Parse an invalid patch header"""
56
100
    def testValidHunkHeader(self):
57
101
        """Parse a valid hunk header"""
58
102
        header = "@@ -34,11 +50,6 @@\n"
59
 
        hunk = hunk_from_header(header);
60
 
        assert (hunk.orig_pos == 34)
61
 
        assert (hunk.orig_range == 11)
62
 
        assert (hunk.mod_pos == 50)
63
 
        assert (hunk.mod_range == 6)
64
 
        assert (str(hunk) == header)
 
103
        hunk = hunk_from_header(header)
 
104
        self.assertEqual(hunk.orig_pos, 34)
 
105
        self.assertEqual(hunk.orig_range, 11)
 
106
        self.assertEqual(hunk.mod_pos, 50)
 
107
        self.assertEqual(hunk.mod_range, 6)
 
108
        self.assertEqual(str(hunk), header)
65
109
 
66
110
    def testValidHunkHeader2(self):
67
111
        """Parse a tricky, valid hunk header"""
68
112
        header = "@@ -1 +0,0 @@\n"
69
 
        hunk = hunk_from_header(header);
70
 
        assert (hunk.orig_pos == 1)
71
 
        assert (hunk.orig_range == 1)
72
 
        assert (hunk.mod_pos == 0)
73
 
        assert (hunk.mod_range == 0)
74
 
        assert (str(hunk) == header)
 
113
        hunk = hunk_from_header(header)
 
114
        self.assertEqual(hunk.orig_pos, 1)
 
115
        self.assertEqual(hunk.orig_range, 1)
 
116
        self.assertEqual(hunk.mod_pos, 0)
 
117
        self.assertEqual(hunk.mod_range, 0)
 
118
        self.assertEqual(str(hunk), header)
 
119
 
 
120
    def testPDiff(self):
 
121
        """Parse a hunk header produced by diff -p"""
 
122
        header = "@@ -407,7 +292,7 @@ bzr 0.18rc1  2007-07-10\n"
 
123
        hunk = hunk_from_header(header)
 
124
        self.assertEqual('bzr 0.18rc1  2007-07-10', hunk.tail)
 
125
        self.assertEqual(header, str(hunk))
75
126
 
76
127
    def makeMalformed(self, header):
77
128
        self.assertRaises(MalformedHunkHeader, hunk_from_header, header)
88
139
        self.makeMalformed("@@ -34,11 +50,6.5 @@\n")
89
140
        self.makeMalformed("@@ -34,11 +50,-6 @@\n")
90
141
 
91
 
    def lineThing(self,text, type):
 
142
    def lineThing(self, text, type):
92
143
        line = parse_line(text)
93
 
        assert(isinstance(line, type))
94
 
        assert(str(line)==text)
 
144
        self.assertIsInstance(line, type)
 
145
        self.assertEqual(str(line), text)
95
146
 
96
147
    def makeMalformedLine(self, text):
97
148
        self.assertRaises(MalformedLine, parse_line, text)
101
152
        self.lineThing(" hello\n", ContextLine)
102
153
        self.lineThing("+hello\n", InsertLine)
103
154
        self.lineThing("-hello\n", RemoveLine)
104
 
    
 
155
 
105
156
    def testMalformedLine(self):
106
157
        """Parse invalid valid hunk lines"""
107
158
        self.makeMalformedLine("hello\n")
108
 
    
 
159
 
 
160
    def testMalformedLineNO_NL(self):
 
161
        """Parse invalid '\ No newline at end of file' in hunk lines"""
 
162
        self.makeMalformedLine(NO_NL)
 
163
 
109
164
    def compare_parsed(self, patchtext):
110
165
        lines = patchtext.splitlines(True)
111
166
        patch = parse_patch(lines.__iter__())
113
168
        i = difference_index(patchtext, pstr)
114
169
        if i is not None:
115
170
            print "%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i])
116
 
        self.assertEqual (patchtext, str(patch))
 
171
        self.assertEqual(patchtext, str(patch))
117
172
 
118
173
    def testAll(self):
119
174
        """Test parsing a whole patch"""
120
175
        patchtext = self.datafile("patchtext.patch").read()
121
176
        self.compare_parsed(patchtext)
122
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
 
123
202
    def testInit(self):
124
203
        """Handle patches missing half the position, range tuple"""
125
204
        patchtext = \
143
222
            if mod_pos is None:
144
223
                removals.append(orig[i])
145
224
                continue
146
 
            assert(mod[mod_pos]==orig[i])
 
225
            self.assertEqual(mod[mod_pos], orig[i])
147
226
        rem_iter = removals.__iter__()
148
227
        for hunk in patch.hunks:
149
228
            for line in hunk.lines:
152
231
                    if line.contents != next:
153
232
                        sys.stdout.write(" orig:%spatch:%s" % (next,
154
233
                                         line.contents))
155
 
                    assert(line.contents == next)
 
234
                    self.assertEqual(line.contents, next)
156
235
        self.assertRaises(StopIteration, rem_iter.next)
157
236
 
158
237
    def testPatching(self):
163
242
            ('diff-4', 'orig-4', 'mod-4'),
164
243
            ('diff-5', 'orig-5', 'mod-5'),
165
244
            ('diff-6', 'orig-6', 'mod-6'),
 
245
            ('diff-7', 'orig-7', 'mod-7'),
166
246
        ]
167
247
        for diff, orig, mod in files:
168
248
            patch = self.datafile(diff)
170
250
            mod_lines = list(self.datafile(mod))
171
251
 
172
252
            patched_file = IterableFile(iter_patched(orig_lines, patch))
173
 
            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)
174
279
            count = 0
175
280
            for patch_line in patched_file:
176
281
                self.assertEqual(patch_line, mod_lines[count])
180
285
    def testFirstLineRenumber(self):
181
286
        """Make sure we handle lines at the beginning of the hunk"""
182
287
        patch = parse_patch(self.datafile("insert_top.patch"))
183
 
        assert (patch.pos_in_mod(0)==1)
184
 
 
185
 
def test():
186
 
    patchesTestSuite = unittest.makeSuite(PatchesTester,'test')
187
 
    runner = unittest.TextTestRunner(verbosity=0)
188
 
    return runner.run(patchesTestSuite)
189
 
 
190
 
 
191
 
if __name__ == "__main__":
192
 
    test()
 
288
        self.assertEqual(patch.pos_in_mod(0), 1)
 
289
 
 
290
    def testParsePatches(self):
 
291
        """Make sure file names can be extracted from tricky unified diffs"""
 
292
        patchtext = \
 
293
"""--- orig-7
 
294
+++ mod-7
 
295
@@ -1,10 +1,10 @@
 
296
 -- a
 
297
--- b
 
298
+++ c
 
299
 xx d
 
300
 xx e
 
301
 ++ f
 
302
-++ g
 
303
+-- h
 
304
 xx i
 
305
 xx j
 
306
 -- k
 
307
--- l
 
308
+++ m
 
309
--- orig-8
 
310
+++ mod-8
 
311
@@ -1 +1 @@
 
312
--- A
 
313
+++ B
 
314
@@ -1 +1 @@
 
315
--- C
 
316
+++ D
 
317
"""
 
318
        filenames = [('orig-7', 'mod-7'),
 
319
                     ('orig-8', 'mod-8')]
 
320
        patches = parse_patches(patchtext.splitlines(True))
 
321
        patch_files = []
 
322
        for patch in patches:
 
323
            patch_files.append((patch.oldname, patch.newname))
 
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())