/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_patches.py

  • Committer: Robert Collins
  • Date: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_patches.py
1
 
# Copyright (C) 2005-2010 Aaron Bentley, Canonical Ltd
 
1
# Copyright (C) 2004 - 2006 Aaron Bentley, Canonical Ltd
 
2
# <aaron.bentley@utoronto.ca>
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
12
13
#
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
 
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
 
 
19
import unittest
18
20
import os.path
19
21
 
20
 
from breezy.tests import TestCase, TestCaseWithTransport
21
 
 
22
 
from breezy.iterablefile import IterableFile
23
 
from breezy.patches import (
24
 
    AppliedPatches,
25
 
    MalformedLine,
26
 
    MalformedHunkHeader,
27
 
    MalformedPatchHeader,
28
 
    BinaryPatch,
29
 
    BinaryFiles,
30
 
    Patch,
31
 
    ContextLine,
32
 
    InsertLine,
33
 
    RemoveLine,
34
 
    difference_index,
35
 
    get_patch_names,
36
 
    hunk_from_header,
37
 
    iter_patched,
38
 
    iter_patched_from_hunks,
39
 
    parse_line,
40
 
    parse_patch,
41
 
    parse_patches,
42
 
    NO_NL,
43
 
    )
44
 
 
45
 
 
46
 
class PatchesTester(TestCase):
47
 
 
 
22
from bzrlib.iterablefile import IterableFile
 
23
from bzrlib.patches import (MalformedLine, 
 
24
                            MalformedHunkHeader, 
 
25
                            MalformedPatchHeader, 
 
26
                            ContextLine, 
 
27
                            InsertLine,
 
28
                            RemoveLine, 
 
29
                            difference_index, 
 
30
                            get_patch_names,
 
31
                            hunk_from_header, 
 
32
                            iter_patched, 
 
33
                            parse_line,
 
34
                            parse_patch,
 
35
                            parse_patches)
 
36
 
 
37
 
 
38
class PatchesTester(unittest.TestCase):
48
39
    def datafile(self, filename):
49
 
        data_path = os.path.join(os.path.dirname(__file__),
 
40
        data_path = os.path.join(os.path.dirname(__file__), 
50
41
                                 "test_patches_data", filename)
51
 
        return open(data_path, "rb")
52
 
 
53
 
    def data_lines(self, filename):
54
 
        with self.datafile(filename) as datafile:
55
 
            return datafile.readlines()
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 = [b"diff -pruN commands.py",
61
 
                 b"--- orig/commands.py",
62
 
                 b"+++ mod/dommands.py"]
63
 
        bits = list(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 = [b"=== added directory 'foo/bar'\n",
68
 
                 b"=== modified file 'orig/commands.py'\n",
69
 
                 b"--- orig/commands.py\n",
70
 
                 b"+++ mod/dommands.py\n",
71
 
                 b"=== modified file 'orig/another.py'\n",
72
 
                 b"--- orig/another.py\n",
73
 
                 b"+++ mod/another.py\n"]
74
 
        patches = list(parse_patches(
75
 
            lines.__iter__(), allow_dirty=True, keep_dirty=True))
76
 
        self.assertLength(2, patches)
77
 
        self.assertEqual(patches[0]['dirty_head'],
78
 
                         [b"=== added directory 'foo/bar'\n",
79
 
                          b"=== modified file 'orig/commands.py'\n"])
80
 
        self.assertEqual(patches[0]['patch'].get_header().splitlines(True),
81
 
                         [b"--- orig/commands.py\n", b"+++ mod/dommands.py\n"])
82
 
        self.assertEqual(patches[1]['dirty_head'],
83
 
                         [b"=== modified file 'orig/another.py'\n"])
84
 
        self.assertEqual(patches[1]['patch'].get_header().splitlines(True),
85
 
                         [b"--- orig/another.py\n", b"+++ mod/another.py\n"])
 
42
        return file(data_path, "rb")
86
43
 
87
44
    def testValidPatchHeader(self):
88
45
        """Parse a valid patch header"""
89
 
        lines = b"--- orig/commands.py\n+++ mod/dommands.py\n".split(b'\n')
 
46
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
90
47
        (orig, mod) = get_patch_names(lines.__iter__())
91
 
        self.assertEqual(orig, b"orig/commands.py")
92
 
        self.assertEqual(mod, b"mod/dommands.py")
 
48
        assert(orig == "orig/commands.py")
 
49
        assert(mod == "mod/dommands.py")
93
50
 
94
51
    def testInvalidPatchHeader(self):
95
52
        """Parse an invalid patch header"""
96
 
        lines = b"-- orig/commands.py\n+++ mod/dommands.py".split(b'\n')
 
53
        lines = "-- orig/commands.py\n+++ mod/dommands.py".split('\n')
97
54
        self.assertRaises(MalformedPatchHeader, get_patch_names,
98
55
                          lines.__iter__())
99
56
 
100
57
    def testValidHunkHeader(self):
101
58
        """Parse a valid hunk header"""
102
 
        header = b"@@ -34,11 +50,6 @@\n"
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(hunk.as_bytes(), header)
 
59
        header = "@@ -34,11 +50,6 @@\n"
 
60
        hunk = hunk_from_header(header);
 
61
        assert (hunk.orig_pos == 34)
 
62
        assert (hunk.orig_range == 11)
 
63
        assert (hunk.mod_pos == 50)
 
64
        assert (hunk.mod_range == 6)
 
65
        assert (str(hunk) == header)
109
66
 
110
67
    def testValidHunkHeader2(self):
111
68
        """Parse a tricky, valid hunk header"""
112
 
        header = b"@@ -1 +0,0 @@\n"
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(hunk.as_bytes(), header)
119
 
 
120
 
    def testPDiff(self):
121
 
        """Parse a hunk header produced by diff -p"""
122
 
        header = b"@@ -407,7 +292,7 @@ bzr 0.18rc1  2007-07-10\n"
123
 
        hunk = hunk_from_header(header)
124
 
        self.assertEqual(b'bzr 0.18rc1  2007-07-10', hunk.tail)
125
 
        self.assertEqual(header, hunk.as_bytes())
 
69
        header = "@@ -1 +0,0 @@\n"
 
70
        hunk = hunk_from_header(header);
 
71
        assert (hunk.orig_pos == 1)
 
72
        assert (hunk.orig_range == 1)
 
73
        assert (hunk.mod_pos == 0)
 
74
        assert (hunk.mod_range == 0)
 
75
        assert (str(hunk) == header)
126
76
 
127
77
    def makeMalformed(self, header):
128
78
        self.assertRaises(MalformedHunkHeader, hunk_from_header, header)
129
79
 
130
80
    def testInvalidHeader(self):
131
81
        """Parse an invalid hunk header"""
132
 
        self.makeMalformed(b" -34,11 +50,6 \n")
133
 
        self.makeMalformed(b"@@ +50,6 -34,11 @@\n")
134
 
        self.makeMalformed(b"@@ -34,11 +50,6 @@")
135
 
        self.makeMalformed(b"@@ -34.5,11 +50,6 @@\n")
136
 
        self.makeMalformed(b"@@-34,11 +50,6@@\n")
137
 
        self.makeMalformed(b"@@ 34,11 50,6 @@\n")
138
 
        self.makeMalformed(b"@@ -34,11 @@\n")
139
 
        self.makeMalformed(b"@@ -34,11 +50,6.5 @@\n")
140
 
        self.makeMalformed(b"@@ -34,11 +50,-6 @@\n")
 
82
        self.makeMalformed(" -34,11 +50,6 \n")
 
83
        self.makeMalformed("@@ +50,6 -34,11 @@\n")
 
84
        self.makeMalformed("@@ -34,11 +50,6 @@")
 
85
        self.makeMalformed("@@ -34.5,11 +50,6 @@\n")
 
86
        self.makeMalformed("@@-34,11 +50,6@@\n")
 
87
        self.makeMalformed("@@ 34,11 50,6 @@\n")
 
88
        self.makeMalformed("@@ -34,11 @@\n")
 
89
        self.makeMalformed("@@ -34,11 +50,6.5 @@\n")
 
90
        self.makeMalformed("@@ -34,11 +50,-6 @@\n")
141
91
 
142
 
    def lineThing(self, text, type):
 
92
    def lineThing(self,text, type):
143
93
        line = parse_line(text)
144
 
        self.assertIsInstance(line, type)
145
 
        self.assertEqual(line.as_bytes(), text)
 
94
        assert(isinstance(line, type))
 
95
        assert(str(line)==text)
146
96
 
147
97
    def makeMalformedLine(self, text):
148
98
        self.assertRaises(MalformedLine, parse_line, text)
149
99
 
150
100
    def testValidLine(self):
151
101
        """Parse a valid hunk line"""
152
 
        self.lineThing(b" hello\n", ContextLine)
153
 
        self.lineThing(b"+hello\n", InsertLine)
154
 
        self.lineThing(b"-hello\n", RemoveLine)
155
 
 
 
102
        self.lineThing(" hello\n", ContextLine)
 
103
        self.lineThing("+hello\n", InsertLine)
 
104
        self.lineThing("-hello\n", RemoveLine)
 
105
    
156
106
    def testMalformedLine(self):
157
107
        """Parse invalid valid hunk lines"""
158
 
        self.makeMalformedLine(b"hello\n")
159
 
 
160
 
    def testMalformedLineNO_NL(self):
161
 
        """Parse invalid '\\ No newline at end of file' in hunk lines"""
162
 
        self.makeMalformedLine(NO_NL)
163
 
 
 
108
        self.makeMalformedLine("hello\n")
 
109
    
164
110
    def compare_parsed(self, patchtext):
165
111
        lines = patchtext.splitlines(True)
166
112
        patch = parse_patch(lines.__iter__())
167
 
        pstr = patch.as_bytes()
 
113
        pstr = str(patch)
168
114
        i = difference_index(patchtext, pstr)
169
115
        if i is not None:
170
 
            print("%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i]))
171
 
        self.assertEqual(patchtext, patch.as_bytes())
 
116
            print "%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i])
 
117
        self.assertEqual (patchtext, str(patch))
172
118
 
173
119
    def testAll(self):
174
120
        """Test parsing a whole patch"""
175
 
        with self.datafile("patchtext.patch") as f:
176
 
            patchtext = f.read()
 
121
        patchtext = self.datafile("patchtext.patch").read()
177
122
        self.compare_parsed(patchtext)
178
123
 
179
 
    def test_parse_binary(self):
180
 
        """Test parsing a whole patch"""
181
 
        patches = list(parse_patches(self.data_lines("binary.patch")))
182
 
        self.assertIs(BinaryPatch, patches[0].__class__)
183
 
        self.assertIs(Patch, patches[1].__class__)
184
 
        self.assertContainsRe(patches[0].oldname, b'^bar\t')
185
 
        self.assertContainsRe(patches[0].newname, b'^qux\t')
186
 
        self.assertContainsRe(patches[0].as_bytes(),
187
 
                              b'Binary files bar\t.* and qux\t.* differ\n')
188
 
 
189
 
    def test_parse_binary_after_normal(self):
190
 
        patches = list(parse_patches(
191
 
            self.data_lines("binary-after-normal.patch")))
192
 
        self.assertIs(BinaryPatch, patches[1].__class__)
193
 
        self.assertIs(Patch, patches[0].__class__)
194
 
        self.assertContainsRe(patches[1].oldname, b'^bar\t')
195
 
        self.assertContainsRe(patches[1].newname, b'^qux\t')
196
 
        self.assertContainsRe(patches[1].as_bytes(),
197
 
                              b'Binary files bar\t.* and qux\t.* differ\n')
198
 
 
199
 
    def test_roundtrip_binary(self):
200
 
        patchtext = b''.join(self.data_lines("binary.patch"))
201
 
        patches = parse_patches(patchtext.splitlines(True))
202
 
        self.assertEqual(patchtext, b''.join(p.as_bytes() for p in patches))
203
 
 
204
124
    def testInit(self):
205
125
        """Handle patches missing half the position, range tuple"""
206
126
        patchtext = \
207
 
            b"""--- orig/__vavg__.cl
 
127
"""--- orig/__vavg__.cl
208
128
+++ mod/__vavg__.cl
209
129
@@ -1 +1,2 @@
210
130
 __qbpsbezng__ = "erfgehpgherqgrkg ra"
213
133
        self.compare_parsed(patchtext)
214
134
 
215
135
    def testLineLookup(self):
 
136
        import sys
216
137
        """Make sure we can accurately look up mod line from orig"""
217
138
        patch = parse_patch(self.datafile("diff"))
218
139
        orig = list(self.datafile("orig"))
223
144
            if mod_pos is None:
224
145
                removals.append(orig[i])
225
146
                continue
226
 
            self.assertEqual(mod[mod_pos], orig[i])
 
147
            assert(mod[mod_pos]==orig[i])
227
148
        rem_iter = removals.__iter__()
228
149
        for hunk in patch.hunks:
229
150
            for line in hunk.lines:
230
151
                if isinstance(line, RemoveLine):
231
 
                    self.assertEqual(line.contents, next(rem_iter))
232
 
        self.assertRaises(StopIteration, next, rem_iter)
 
152
                    next = rem_iter.next()
 
153
                    if line.contents != next:
 
154
                        sys.stdout.write(" orig:%spatch:%s" % (next,
 
155
                                         line.contents))
 
156
                    assert(line.contents == next)
 
157
        self.assertRaises(StopIteration, rem_iter.next)
233
158
 
234
159
    def testPatching(self):
235
160
        """Test a few patch files, and make sure they work."""
239
164
            ('diff-4', 'orig-4', 'mod-4'),
240
165
            ('diff-5', 'orig-5', 'mod-5'),
241
166
            ('diff-6', 'orig-6', 'mod-6'),
242
 
            ('diff-7', 'orig-7', 'mod-7'),
243
167
        ]
244
168
        for diff, orig, mod in files:
245
169
            patch = self.datafile(diff)
247
171
            mod_lines = list(self.datafile(mod))
248
172
 
249
173
            patched_file = IterableFile(iter_patched(orig_lines, patch))
250
 
            count = 0
251
 
            for patch_line in patched_file:
252
 
                self.assertEqual(patch_line, mod_lines[count])
253
 
                count += 1
254
 
            self.assertEqual(count, len(mod_lines))
255
 
 
256
 
    def test_iter_patched_binary(self):
257
 
        binary_lines = self.data_lines('binary.patch')
258
 
        e = self.assertRaises(BinaryFiles, iter_patched, [], binary_lines)
259
 
 
260
 
    def test_iter_patched_from_hunks(self):
261
 
        """Test a few patch files, and make sure they work."""
262
 
        files = [
263
 
            ('diff-2', 'orig-2', 'mod-2'),
264
 
            ('diff-3', 'orig-3', 'mod-3'),
265
 
            ('diff-4', 'orig-4', 'mod-4'),
266
 
            ('diff-5', 'orig-5', 'mod-5'),
267
 
            ('diff-6', 'orig-6', 'mod-6'),
268
 
            ('diff-7', 'orig-7', 'mod-7'),
269
 
        ]
270
 
        for diff, orig, mod in files:
271
 
            parsed = parse_patch(self.datafile(diff))
272
 
            orig_lines = list(self.datafile(orig))
273
 
            mod_lines = list(self.datafile(mod))
274
 
            iter_patched = iter_patched_from_hunks(orig_lines, parsed.hunks)
275
 
            patched_file = IterableFile(iter_patched)
 
174
            lines = []
276
175
            count = 0
277
176
            for patch_line in patched_file:
278
177
                self.assertEqual(patch_line, mod_lines[count])
282
181
    def testFirstLineRenumber(self):
283
182
        """Make sure we handle lines at the beginning of the hunk"""
284
183
        patch = parse_patch(self.datafile("insert_top.patch"))
285
 
        self.assertEqual(patch.pos_in_mod(0), 1)
 
184
        assert (patch.pos_in_mod(0)==1)
286
185
 
287
186
    def testParsePatches(self):
288
187
        """Make sure file names can be extracted from tricky unified diffs"""
289
188
        patchtext = \
290
 
            b"""--- orig-7
 
189
"""--- orig-7
291
190
+++ mod-7
292
191
@@ -1,10 +1,10 @@
293
192
 -- a
312
211
--- C
313
212
+++ D
314
213
"""
315
 
        filenames = [(b'orig-7', b'mod-7'),
316
 
                     (b'orig-8', b'mod-8')]
 
214
        filenames = [('orig-7', 'mod-7'),
 
215
                     ('orig-8', 'mod-8')]
317
216
        patches = parse_patches(patchtext.splitlines(True))
318
217
        patch_files = []
319
218
        for patch in patches:
320
219
            patch_files.append((patch.oldname, patch.newname))
321
 
        self.assertEqual(patch_files, filenames)
322
 
 
323
 
    def testStatsValues(self):
324
 
        """Test the added, removed and hunks values for stats_values."""
325
 
        patch = parse_patch(self.datafile("diff"))
326
 
        self.assertEqual((299, 407, 48), patch.stats_values())
327
 
 
328
 
 
329
 
class AppliedPatchesTests(TestCaseWithTransport):
330
 
 
331
 
    def test_apply_simple(self):
332
 
        tree = self.make_branch_and_tree('.')
333
 
        self.build_tree_contents([('a', 'a\n')])
334
 
        tree.add('a')
335
 
        tree.commit('Add a')
336
 
        patch = parse_patch(b"""\
337
 
--- a/a
338
 
+++ a/a
339
 
@@ -1 +1 @@
340
 
-a
341
 
+b
342
 
""".splitlines(True))
343
 
        with AppliedPatches(tree, [patch]) as newtree:
344
 
            self.assertEqual(b'b\n', newtree.get_file_text('a'))
345
 
 
346
 
    def test_apply_delete(self):
347
 
        tree = self.make_branch_and_tree('.')
348
 
        self.build_tree_contents([('a', 'a\n')])
349
 
        tree.add('a')
350
 
        tree.commit('Add a')
351
 
        patch = parse_patch(b"""\
352
 
--- a/a
353
 
+++ /dev/null
354
 
@@ -1 +0,0 @@
355
 
-a
356
 
""".splitlines(True))
357
 
        with AppliedPatches(tree, [patch]) as newtree:
358
 
            self.assertFalse(newtree.has_filename('a'))
359
 
 
360
 
    def test_apply_add(self):
361
 
        tree = self.make_branch_and_tree('.')
362
 
        self.build_tree_contents([('a', 'a\n')])
363
 
        tree.add('a')
364
 
        tree.commit('Add a')
365
 
        patch = parse_patch(b"""\
366
 
--- /dev/null
367
 
+++ a/b
368
 
@@ -0,0 +1 @@
369
 
+b
370
 
""".splitlines(True))
371
 
        with AppliedPatches(tree, [patch]) as newtree:
372
 
            self.assertEqual(b'b\n', newtree.get_file_text('b'))
 
220
        assert (patch_files == filenames)
 
221
            
 
222
def test():
 
223
    patchesTestSuite = unittest.makeSuite(PatchesTester,'test')
 
224
    runner = unittest.TextTestRunner(verbosity=0)
 
225
    return runner.run(patchesTestSuite)
 
226
 
 
227
 
 
228
if __name__ == "__main__":
 
229
    test()