← 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: Canonical.com Patch Queue Manager
  • Date: 2008-05-06 11:40:10 UTC
  • mfrom: (3400.1.3 trivial)
  • Revision ID: pqm@pqm.ubuntu.com-20080506114010-jwclr2qtiekvawjg
Remove erroneous creation of branch-name file in cmd_branch

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 bzrlib.tests import TestCase
21
 
 
22
22
from bzrlib.iterablefile import IterableFile
23
 
from bzrlib.patches import (MalformedLine,
24
 
                            MalformedHunkHeader,
25
 
                            MalformedPatchHeader,
26
 
                            BinaryPatch,
27
 
                            BinaryFiles,
28
 
                            Patch,
29
 
                            ContextLine,
 
23
from bzrlib.patches import (MalformedLine, 
 
24
                            MalformedHunkHeader, 
 
25
                            MalformedPatchHeader, 
 
26
                            ContextLine, 
30
27
                            InsertLine,
31
 
                            RemoveLine,
32
 
                            difference_index,
 
28
                            RemoveLine, 
 
29
                            difference_index, 
33
30
                            get_patch_names,
34
 
                            hunk_from_header,
35
 
                            iter_patched,
36
 
                            iter_patched_from_hunks,
 
31
                            hunk_from_header, 
 
32
                            iter_patched, 
37
33
                            parse_line,
38
34
                            parse_patch,
39
 
                            parse_patches,
40
 
                            NO_NL)
41
 
 
42
 
 
43
 
class PatchesTester(TestCase):
44
 
 
 
35
                            parse_patches)
 
36
 
 
37
 
 
38
class PatchesTester(unittest.TestCase):
45
39
    def datafile(self, filename):
46
 
        data_path = os.path.join(os.path.dirname(__file__),
 
40
        data_path = os.path.join(os.path.dirname(__file__), 
47
41
                                 "test_patches_data", filename)
48
42
        return file(data_path, "rb")
49
43
 
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
44
    def testValidPatchHeader(self):
66
45
        """Parse a valid patch header"""
67
46
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
68
47
        (orig, mod) = get_patch_names(lines.__iter__())
69
 
        self.assertEqual(orig, "orig/commands.py")
70
 
        self.assertEqual(mod, "mod/dommands.py")
 
48
        assert(orig == "orig/commands.py")
 
49
        assert(mod == "mod/dommands.py")
71
50
 
72
51
    def testInvalidPatchHeader(self):
73
52
        """Parse an invalid patch header"""
79
58
        """Parse a valid hunk header"""
80
59
        header = "@@ -34,11 +50,6 @@\n"
81
60
        hunk = hunk_from_header(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)
 
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)
87
66
 
88
67
    def testValidHunkHeader2(self):
89
68
        """Parse a tricky, valid hunk header"""
90
69
        header = "@@ -1 +0,0 @@\n"
91
70
        hunk = hunk_from_header(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)
 
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)
97
76
 
98
77
    def testPDiff(self):
99
78
        """Parse a hunk header produced by diff -p"""
119
98
 
120
99
    def lineThing(self,text, type):
121
100
        line = parse_line(text)
122
 
        self.assertIsInstance(line, type)
123
 
        self.assertEqual(str(line), text)
 
101
        assert(isinstance(line, type))
 
102
        assert(str(line)==text)
124
103
 
125
104
    def makeMalformedLine(self, text):
126
105
        self.assertRaises(MalformedLine, parse_line, text)
130
109
        self.lineThing(" hello\n", ContextLine)
131
110
        self.lineThing("+hello\n", InsertLine)
132
111
        self.lineThing("-hello\n", RemoveLine)
133
 
 
 
112
    
134
113
    def testMalformedLine(self):
135
114
        """Parse invalid valid hunk lines"""
136
115
        self.makeMalformedLine("hello\n")
137
 
 
138
 
    def testMalformedLineNO_NL(self):
139
 
        """Parse invalid '\ No newline at end of file' in hunk lines"""
140
 
        self.makeMalformedLine(NO_NL)
141
 
 
 
116
    
142
117
    def compare_parsed(self, patchtext):
143
118
        lines = patchtext.splitlines(True)
144
119
        patch = parse_patch(lines.__iter__())
153
128
        patchtext = self.datafile("patchtext.patch").read()
154
129
        self.compare_parsed(patchtext)
155
130
 
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
 
 
180
131
    def testInit(self):
181
132
        """Handle patches missing half the position, range tuple"""
182
133
        patchtext = \
200
151
            if mod_pos is None:
201
152
                removals.append(orig[i])
202
153
                continue
203
 
            self.assertEqual(mod[mod_pos], orig[i])
 
154
            assert(mod[mod_pos]==orig[i])
204
155
        rem_iter = removals.__iter__()
205
156
        for hunk in patch.hunks:
206
157
            for line in hunk.lines:
209
160
                    if line.contents != next:
210
161
                        sys.stdout.write(" orig:%spatch:%s" % (next,
211
162
                                         line.contents))
212
 
                    self.assertEqual(line.contents, next)
 
163
                    assert(line.contents == next)
213
164
        self.assertRaises(StopIteration, rem_iter.next)
214
165
 
215
166
    def testPatching(self):
220
171
            ('diff-4', 'orig-4', 'mod-4'),
221
172
            ('diff-5', 'orig-5', 'mod-5'),
222
173
            ('diff-6', 'orig-6', 'mod-6'),
223
 
            ('diff-7', 'orig-7', 'mod-7'),
224
174
        ]
225
175
        for diff, orig, mod in files:
226
176
            patch = self.datafile(diff)
235
185
                count += 1
236
186
            self.assertEqual(count, len(mod_lines))
237
187
 
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
 
 
243
 
    def test_iter_patched_from_hunks(self):
244
 
        """Test a few patch files, and make sure they work."""
245
 
        files = [
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'),
252
 
        ]
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)
259
 
            lines = []
260
 
            count = 0
261
 
            for patch_line in patched_file:
262
 
                self.assertEqual(patch_line, mod_lines[count])
263
 
                count += 1
264
 
            self.assertEqual(count, len(mod_lines))
265
 
 
266
188
    def testFirstLineRenumber(self):
267
189
        """Make sure we handle lines at the beginning of the hunk"""
268
190
        patch = parse_patch(self.datafile("insert_top.patch"))
269
 
        self.assertEqual(patch.pos_in_mod(0), 1)
 
191
        assert (patch.pos_in_mod(0)==1)
270
192
 
271
193
    def testParsePatches(self):
272
194
        """Make sure file names can be extracted from tricky unified diffs"""
302
224
        patch_files = []
303
225
        for patch in patches:
304
226
            patch_files.append((patch.oldname, patch.newname))
305
 
        self.assertEqual(patch_files, filenames)
306
 
 
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())
 
227
        assert (patch_files == filenames)
 
228
            
 
229
def test():
 
230
    patchesTestSuite = unittest.makeSuite(PatchesTester,'test')
 
231
    runner = unittest.TextTestRunner(verbosity=0)
 
232
    return runner.run(patchesTestSuite)
 
233
 
 
234
 
 
235
if __name__ == "__main__":
 
236
    test()