← 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-09-03 22:30:56 UTC
  • mfrom: (3644.2.13 index_builder_cleanup)
  • Revision ID: pqm@pqm.ubuntu.com-20080903223056-b108iytb38xkznci
(jam) Streamline BTreeBuilder.add_node et al to make btree creation
        faster.

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 - 2008 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
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
18
 
18
19
import os.path
20
21
from bzrlib.tests import TestCase
21
22
 
22
23
from bzrlib.iterablefile import IterableFile
23
 
from bzrlib.patches import (MalformedLine,
24
 
                            MalformedHunkHeader,
25
 
                            MalformedPatchHeader,
26
 
                            BinaryPatch,
27
 
                            BinaryFiles,
28
 
                            Patch,
29
 
                            ContextLine,
 
24
from bzrlib.patches import (MalformedLine, 
 
25
                            MalformedHunkHeader, 
 
26
                            MalformedPatchHeader, 
 
27
                            ContextLine, 
30
28
                            InsertLine,
31
 
                            RemoveLine,
32
 
                            difference_index,
 
29
                            RemoveLine, 
 
30
                            difference_index, 
33
31
                            get_patch_names,
34
 
                            hunk_from_header,
35
 
                            iter_patched,
36
 
                            iter_patched_from_hunks,
 
32
                            hunk_from_header, 
 
33
                            iter_patched, 
37
34
                            parse_line,
38
35
                            parse_patch,
39
 
                            parse_patches,
40
 
                            NO_NL)
 
36
                            parse_patches)
41
37
 
42
38
 
43
39
class PatchesTester(TestCase):
44
40
 
45
41
    def datafile(self, filename):
46
 
        data_path = os.path.join(os.path.dirname(__file__),
 
42
        data_path = os.path.join(os.path.dirname(__file__), 
47
43
                                 "test_patches_data", filename)
48
44
        return file(data_path, "rb")
49
45
 
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
 
 
87
46
    def testValidPatchHeader(self):
88
47
        """Parse a valid patch header"""
89
48
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
100
59
    def testValidHunkHeader(self):
101
60
        """Parse a valid hunk header"""
102
61
        header = "@@ -34,11 +50,6 @@\n"
103
 
        hunk = hunk_from_header(header)
 
62
        hunk = hunk_from_header(header);
104
63
        self.assertEqual(hunk.orig_pos, 34)
105
64
        self.assertEqual(hunk.orig_range, 11)
106
65
        self.assertEqual(hunk.mod_pos, 50)
110
69
    def testValidHunkHeader2(self):
111
70
        """Parse a tricky, valid hunk header"""
112
71
        header = "@@ -1 +0,0 @@\n"
113
 
        hunk = hunk_from_header(header)
 
72
        hunk = hunk_from_header(header);
114
73
        self.assertEqual(hunk.orig_pos, 1)
115
74
        self.assertEqual(hunk.orig_range, 1)
116
75
        self.assertEqual(hunk.mod_pos, 0)
139
98
        self.makeMalformed("@@ -34,11 +50,6.5 @@\n")
140
99
        self.makeMalformed("@@ -34,11 +50,-6 @@\n")
141
100
 
142
 
    def lineThing(self, text, type):
 
101
    def lineThing(self,text, type):
143
102
        line = parse_line(text)
144
103
        self.assertIsInstance(line, type)
145
104
        self.assertEqual(str(line), text)
152
111
        self.lineThing(" hello\n", ContextLine)
153
112
        self.lineThing("+hello\n", InsertLine)
154
113
        self.lineThing("-hello\n", RemoveLine)
155
 
 
 
114
    
156
115
    def testMalformedLine(self):
157
116
        """Parse invalid valid hunk lines"""
158
117
        self.makeMalformedLine("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
 
 
 
118
    
164
119
    def compare_parsed(self, patchtext):
165
120
        lines = patchtext.splitlines(True)
166
121
        patch = parse_patch(lines.__iter__())
168
123
        i = difference_index(patchtext, pstr)
169
124
        if i is not None:
170
125
            print "%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i])
171
 
        self.assertEqual(patchtext, str(patch))
 
126
        self.assertEqual (patchtext, str(patch))
172
127
 
173
128
    def testAll(self):
174
129
        """Test parsing a whole patch"""
175
130
        patchtext = self.datafile("patchtext.patch").read()
176
131
        self.compare_parsed(patchtext)
177
132
 
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
 
 
202
133
    def testInit(self):
203
134
        """Handle patches missing half the position, range tuple"""
204
135
        patchtext = \
242
173
            ('diff-4', 'orig-4', 'mod-4'),
243
174
            ('diff-5', 'orig-5', 'mod-5'),
244
175
            ('diff-6', 'orig-6', 'mod-6'),
245
 
            ('diff-7', 'orig-7', 'mod-7'),
246
176
        ]
247
177
        for diff, orig, mod in files:
248
178
            patch = self.datafile(diff)
250
180
            mod_lines = list(self.datafile(mod))
251
181
 
252
182
            patched_file = IterableFile(iter_patched(orig_lines, patch))
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)
 
183
            lines = []
279
184
            count = 0
280
185
            for patch_line in patched_file:
281
186
                self.assertEqual(patch_line, mod_lines[count])
322
227
        for patch in patches:
323
228
            patch_files.append((patch.oldname, patch.newname))
324
229
        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())