← 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: John Arbash Meinel
  • Date: 2008-12-08 18:27:57 UTC
  • mto: This revision was merged to the branch mainline in revision 3912.
  • Revision ID: john@arbash-meinel.com-20081208182757-2rls8q1ri36ub6e9
Add an InventoryEntry cache to the xml deserializer.

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,
 
32
                            hunk_from_header, 
 
33
                            iter_patched, 
36
34
                            iter_patched_from_hunks,
37
35
                            parse_line,
38
36
                            parse_patch,
39
 
                            parse_patches,
40
 
                            NO_NL)
 
37
                            parse_patches)
41
38
 
42
39
 
43
40
class PatchesTester(TestCase):
44
41
 
45
42
    def datafile(self, filename):
46
 
        data_path = os.path.join(os.path.dirname(__file__),
 
43
        data_path = os.path.join(os.path.dirname(__file__), 
47
44
                                 "test_patches_data", filename)
48
45
        return file(data_path, "rb")
49
46
 
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
47
    def testValidPatchHeader(self):
66
48
        """Parse a valid patch header"""
67
49
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
130
112
        self.lineThing(" hello\n", ContextLine)
131
113
        self.lineThing("+hello\n", InsertLine)
132
114
        self.lineThing("-hello\n", RemoveLine)
133
 
 
 
115
    
134
116
    def testMalformedLine(self):
135
117
        """Parse invalid valid hunk lines"""
136
118
        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
 
 
 
119
    
142
120
    def compare_parsed(self, patchtext):
143
121
        lines = patchtext.splitlines(True)
144
122
        patch = parse_patch(lines.__iter__())
153
131
        patchtext = self.datafile("patchtext.patch").read()
154
132
        self.compare_parsed(patchtext)
155
133
 
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
134
    def testInit(self):
181
135
        """Handle patches missing half the position, range tuple"""
182
136
        patchtext = \
220
174
            ('diff-4', 'orig-4', 'mod-4'),
221
175
            ('diff-5', 'orig-5', 'mod-5'),
222
176
            ('diff-6', 'orig-6', 'mod-6'),
223
 
            ('diff-7', 'orig-7', 'mod-7'),
224
177
        ]
225
178
        for diff, orig, mod in files:
226
179
            patch = self.datafile(diff)
235
188
                count += 1
236
189
            self.assertEqual(count, len(mod_lines))
237
190
 
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
191
    def test_iter_patched_from_hunks(self):
244
192
        """Test a few patch files, and make sure they work."""
245
193
        files = [
248
196
            ('diff-4', 'orig-4', 'mod-4'),
249
197
            ('diff-5', 'orig-5', 'mod-5'),
250
198
            ('diff-6', 'orig-6', 'mod-6'),
251
 
            ('diff-7', 'orig-7', 'mod-7'),
252
199
        ]
253
200
        for diff, orig, mod in files:
254
201
            parsed = parse_patch(self.datafile(diff))
303
250
        for patch in patches:
304
251
            patch_files.append((patch.oldname, patch.newname))
305
252
        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())