← 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: Martin Pool
  • Date: 2007-04-04 06:17:31 UTC
  • mto: This revision was merged to the branch mainline in revision 2397.
  • Revision ID: mbp@sourcefrog.net-20070404061731-tt2xrzllqhbodn83
Contents of TODO file moved into bug tracker

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_patches.py
1
 
# Copyright (C) 2004 - 2008 Aaron Bentley, Canonical Ltd
 
1
# Copyright (C) 2004 - 2006 Aaron Bentley, Canonical Ltd
2
2
# <aaron.bentley@utoronto.ca>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
 
 
18
 
 
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
 
 
19
import unittest
19
20
import os.path
20
21
 
21
 
from bzrlib.tests import TestCase
22
 
 
23
22
from bzrlib.iterablefile import IterableFile
24
 
from bzrlib.patches import (MalformedLine,
25
 
                            MalformedHunkHeader,
26
 
                            MalformedPatchHeader,
27
 
                            ContextLine,
 
23
from bzrlib.patches import (MalformedLine, 
 
24
                            MalformedHunkHeader, 
 
25
                            MalformedPatchHeader, 
 
26
                            ContextLine, 
28
27
                            InsertLine,
29
 
                            RemoveLine,
30
 
                            difference_index,
 
28
                            RemoveLine, 
 
29
                            difference_index, 
31
30
                            get_patch_names,
32
 
                            hunk_from_header,
33
 
                            iter_patched,
34
 
                            iter_patched_from_hunks,
 
31
                            hunk_from_header, 
 
32
                            iter_patched, 
35
33
                            parse_line,
36
34
                            parse_patch,
37
 
                            parse_patches,
38
 
                            NO_NL)
39
 
 
40
 
 
41
 
class PatchesTester(TestCase):
42
 
 
 
35
                            parse_patches)
 
36
 
 
37
 
 
38
class PatchesTester(unittest.TestCase):
43
39
    def datafile(self, filename):
44
 
        data_path = os.path.join(os.path.dirname(__file__),
 
40
        data_path = os.path.join(os.path.dirname(__file__), 
45
41
                                 "test_patches_data", filename)
46
42
        return file(data_path, "rb")
47
43
 
49
45
        """Parse a valid patch header"""
50
46
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
51
47
        (orig, mod) = get_patch_names(lines.__iter__())
52
 
        self.assertEqual(orig, "orig/commands.py")
53
 
        self.assertEqual(mod, "mod/dommands.py")
 
48
        assert(orig == "orig/commands.py")
 
49
        assert(mod == "mod/dommands.py")
54
50
 
55
51
    def testInvalidPatchHeader(self):
56
52
        """Parse an invalid patch header"""
62
58
        """Parse a valid hunk header"""
63
59
        header = "@@ -34,11 +50,6 @@\n"
64
60
        hunk = hunk_from_header(header);
65
 
        self.assertEqual(hunk.orig_pos, 34)
66
 
        self.assertEqual(hunk.orig_range, 11)
67
 
        self.assertEqual(hunk.mod_pos, 50)
68
 
        self.assertEqual(hunk.mod_range, 6)
69
 
        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)
70
66
 
71
67
    def testValidHunkHeader2(self):
72
68
        """Parse a tricky, valid hunk header"""
73
69
        header = "@@ -1 +0,0 @@\n"
74
70
        hunk = hunk_from_header(header);
75
 
        self.assertEqual(hunk.orig_pos, 1)
76
 
        self.assertEqual(hunk.orig_range, 1)
77
 
        self.assertEqual(hunk.mod_pos, 0)
78
 
        self.assertEqual(hunk.mod_range, 0)
79
 
        self.assertEqual(str(hunk), header)
80
 
 
81
 
    def testPDiff(self):
82
 
        """Parse a hunk header produced by diff -p"""
83
 
        header = "@@ -407,7 +292,7 @@ bzr 0.18rc1  2007-07-10\n"
84
 
        hunk = hunk_from_header(header)
85
 
        self.assertEqual('bzr 0.18rc1  2007-07-10', hunk.tail)
86
 
        self.assertEqual(header, str(hunk))
 
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)
87
76
 
88
77
    def makeMalformed(self, header):
89
78
        self.assertRaises(MalformedHunkHeader, hunk_from_header, header)
102
91
 
103
92
    def lineThing(self,text, type):
104
93
        line = parse_line(text)
105
 
        self.assertIsInstance(line, type)
106
 
        self.assertEqual(str(line), text)
 
94
        assert(isinstance(line, type))
 
95
        assert(str(line)==text)
107
96
 
108
97
    def makeMalformedLine(self, text):
109
98
        self.assertRaises(MalformedLine, parse_line, text)
113
102
        self.lineThing(" hello\n", ContextLine)
114
103
        self.lineThing("+hello\n", InsertLine)
115
104
        self.lineThing("-hello\n", RemoveLine)
116
 
 
 
105
    
117
106
    def testMalformedLine(self):
118
107
        """Parse invalid valid hunk lines"""
119
108
        self.makeMalformedLine("hello\n")
120
 
 
121
 
    def testMalformedLineNO_NL(self):
122
 
        """Parse invalid '\ No newline at end of file' in hunk lines"""
123
 
        self.makeMalformedLine(NO_NL)
124
 
 
 
109
    
125
110
    def compare_parsed(self, patchtext):
126
111
        lines = patchtext.splitlines(True)
127
112
        patch = parse_patch(lines.__iter__())
159
144
            if mod_pos is None:
160
145
                removals.append(orig[i])
161
146
                continue
162
 
            self.assertEqual(mod[mod_pos], orig[i])
 
147
            assert(mod[mod_pos]==orig[i])
163
148
        rem_iter = removals.__iter__()
164
149
        for hunk in patch.hunks:
165
150
            for line in hunk.lines:
168
153
                    if line.contents != next:
169
154
                        sys.stdout.write(" orig:%spatch:%s" % (next,
170
155
                                         line.contents))
171
 
                    self.assertEqual(line.contents, next)
 
156
                    assert(line.contents == next)
172
157
        self.assertRaises(StopIteration, rem_iter.next)
173
158
 
174
159
    def testPatching(self):
179
164
            ('diff-4', 'orig-4', 'mod-4'),
180
165
            ('diff-5', 'orig-5', 'mod-5'),
181
166
            ('diff-6', 'orig-6', 'mod-6'),
182
 
            ('diff-7', 'orig-7', 'mod-7'),
183
167
        ]
184
168
        for diff, orig, mod in files:
185
169
            patch = self.datafile(diff)
194
178
                count += 1
195
179
            self.assertEqual(count, len(mod_lines))
196
180
 
197
 
    def test_iter_patched_from_hunks(self):
198
 
        """Test a few patch files, and make sure they work."""
199
 
        files = [
200
 
            ('diff-2', 'orig-2', 'mod-2'),
201
 
            ('diff-3', 'orig-3', 'mod-3'),
202
 
            ('diff-4', 'orig-4', 'mod-4'),
203
 
            ('diff-5', 'orig-5', 'mod-5'),
204
 
            ('diff-6', 'orig-6', 'mod-6'),
205
 
            ('diff-7', 'orig-7', 'mod-7'),
206
 
        ]
207
 
        for diff, orig, mod in files:
208
 
            parsed = parse_patch(self.datafile(diff))
209
 
            orig_lines = list(self.datafile(orig))
210
 
            mod_lines = list(self.datafile(mod))
211
 
            iter_patched = iter_patched_from_hunks(orig_lines, parsed.hunks)
212
 
            patched_file = IterableFile(iter_patched)
213
 
            lines = []
214
 
            count = 0
215
 
            for patch_line in patched_file:
216
 
                self.assertEqual(patch_line, mod_lines[count])
217
 
                count += 1
218
 
            self.assertEqual(count, len(mod_lines))
219
 
 
220
181
    def testFirstLineRenumber(self):
221
182
        """Make sure we handle lines at the beginning of the hunk"""
222
183
        patch = parse_patch(self.datafile("insert_top.patch"))
223
 
        self.assertEqual(patch.pos_in_mod(0), 1)
 
184
        assert (patch.pos_in_mod(0)==1)
224
185
 
225
186
    def testParsePatches(self):
226
187
        """Make sure file names can be extracted from tricky unified diffs"""
256
217
        patch_files = []
257
218
        for patch in patches:
258
219
            patch_files.append((patch.oldname, patch.newname))
259
 
        self.assertEqual(patch_files, filenames)
260
 
 
261
 
    def testStatsValues(self):
262
 
        """Test the added, removed and hunks values for stats_values."""
263
 
        patch = parse_patch(self.datafile("diff"))
264
 
        self.assertEqual((299, 407, 48), patch.stats_values())
 
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()