1
# Copyright (C) 2004 - 2006 Aaron Bentley
2
# <aaron.bentley@utoronto.ca>
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 2 of the License, or
7
# (at your option) any later version.
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
# GNU General Public License for more details.
14
# You should have received a copy of the GNU General Public License
15
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1
# Copyright (C) 2005-2010 Aaron Bentley, Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
from bzrlib.tests import TestCase
22
22
from bzrlib.iterablefile import IterableFile
23
from bzrlib.patches import (MalformedLine,
23
from bzrlib.patches import (MalformedLine,
36
iter_patched_from_hunks,
37
class PatchesTester(unittest.TestCase):
43
class PatchesTester(TestCase):
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")
50
def data_lines(self, filename):
51
datafile = self.datafile(filename)
53
return datafile.readlines()
57
def test_parse_patches_leading_noise(self):
58
# https://bugs.edge.launchpad.net/bzr/+bug/502076
59
# https://code.edge.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)
43
65
def testValidPatchHeader(self):
44
66
"""Parse a valid patch header"""
45
67
lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
46
68
(orig, mod) = get_patch_names(lines.__iter__())
47
assert(orig == "orig/commands.py")
48
assert(mod == "mod/dommands.py")
69
self.assertEqual(orig, "orig/commands.py")
70
self.assertEqual(mod, "mod/dommands.py")
50
72
def testInvalidPatchHeader(self):
51
73
"""Parse an invalid patch header"""
57
79
"""Parse a valid hunk header"""
58
80
header = "@@ -34,11 +50,6 @@\n"
59
81
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)
82
self.assertEqual(hunk.orig_pos, 34)
83
self.assertEqual(hunk.orig_range, 11)
84
self.assertEqual(hunk.mod_pos, 50)
85
self.assertEqual(hunk.mod_range, 6)
86
self.assertEqual(str(hunk), header)
66
88
def testValidHunkHeader2(self):
67
89
"""Parse a tricky, valid hunk header"""
68
90
header = "@@ -1 +0,0 @@\n"
69
91
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)
92
self.assertEqual(hunk.orig_pos, 1)
93
self.assertEqual(hunk.orig_range, 1)
94
self.assertEqual(hunk.mod_pos, 0)
95
self.assertEqual(hunk.mod_range, 0)
96
self.assertEqual(str(hunk), header)
99
"""Parse a hunk header produced by diff -p"""
100
header = "@@ -407,7 +292,7 @@ bzr 0.18rc1 2007-07-10\n"
101
hunk = hunk_from_header(header)
102
self.assertEqual('bzr 0.18rc1 2007-07-10', hunk.tail)
103
self.assertEqual(header, str(hunk))
76
105
def makeMalformed(self, header):
77
106
self.assertRaises(MalformedHunkHeader, hunk_from_header, header)
101
130
self.lineThing(" hello\n", ContextLine)
102
131
self.lineThing("+hello\n", InsertLine)
103
132
self.lineThing("-hello\n", RemoveLine)
105
134
def testMalformedLine(self):
106
135
"""Parse invalid valid hunk lines"""
107
136
self.makeMalformedLine("hello\n")
138
def testMalformedLineNO_NL(self):
139
"""Parse invalid '\ No newline at end of file' in hunk lines"""
140
self.makeMalformedLine(NO_NL)
109
142
def compare_parsed(self, patchtext):
110
143
lines = patchtext.splitlines(True)
111
144
patch = parse_patch(lines.__iter__())
120
153
patchtext = self.datafile("patchtext.patch").read()
121
154
self.compare_parsed(patchtext)
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')
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')
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))
123
180
def testInit(self):
124
181
"""Handle patches missing half the position, range tuple"""
163
220
('diff-4', 'orig-4', 'mod-4'),
164
221
('diff-5', 'orig-5', 'mod-5'),
165
222
('diff-6', 'orig-6', 'mod-6'),
223
('diff-7', 'orig-7', 'mod-7'),
167
225
for diff, orig, mod in files:
168
226
patch = self.datafile(diff)
178
236
self.assertEqual(count, len(mod_lines))
238
def test_iter_patched_binary(self):
239
binary_lines = self.data_lines('binary.patch')
240
e = self.assertRaises(BinaryFiles, iter_patched, [], binary_lines)
243
def test_iter_patched_from_hunks(self):
244
"""Test a few patch files, and make sure they work."""
246
('diff-2', 'orig-2', 'mod-2'),
247
('diff-3', 'orig-3', 'mod-3'),
248
('diff-4', 'orig-4', 'mod-4'),
249
('diff-5', 'orig-5', 'mod-5'),
250
('diff-6', 'orig-6', 'mod-6'),
251
('diff-7', 'orig-7', 'mod-7'),
253
for diff, orig, mod in files:
254
parsed = parse_patch(self.datafile(diff))
255
orig_lines = list(self.datafile(orig))
256
mod_lines = list(self.datafile(mod))
257
iter_patched = iter_patched_from_hunks(orig_lines, parsed.hunks)
258
patched_file = IterableFile(iter_patched)
261
for patch_line in patched_file:
262
self.assertEqual(patch_line, mod_lines[count])
264
self.assertEqual(count, len(mod_lines))
180
266
def testFirstLineRenumber(self):
181
267
"""Make sure we handle lines at the beginning of the hunk"""
182
268
patch = parse_patch(self.datafile("insert_top.patch"))
183
assert (patch.pos_in_mod(0)==1)
186
patchesTestSuite = unittest.makeSuite(PatchesTester,'test')
187
runner = unittest.TextTestRunner(verbosity=0)
188
return runner.run(patchesTestSuite)
191
if __name__ == "__main__":
269
self.assertEqual(patch.pos_in_mod(0), 1)
271
def testParsePatches(self):
272
"""Make sure file names can be extracted from tricky unified diffs"""
299
filenames = [('orig-7', 'mod-7'),
301
patches = parse_patches(patchtext.splitlines(True))
303
for patch in patches:
304
patch_files.append((patch.oldname, patch.newname))
305
self.assertEqual(patch_files, filenames)
307
def testStatsValues(self):
308
"""Test the added, removed and hunks values for stats_values."""
309
patch = parse_patch(self.datafile("diff"))
310
self.assertEqual((299, 407, 48), patch.stats_values())