← 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: Patch Queue Manager
  • Date: 2014-10-06 16:32:42 UTC
  • mfrom: (6597.2.4 split-diff-tests)
  • Revision ID: pqm@pqm.ubuntu.com-20141006163242-c2cll01cwc24grkk
(vila) Split some tests to be able to get finer grained failures (Vincent
 Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_patches.py
58
58
        # https://bugs.launchpad.net/bzr/+bug/502076
59
59
        # https://code.launchpad.net/~toshio/bzr/allow-dirty-patches/+merge/18854
60
60
        lines = ["diff -pruN commands.py",
61
 
                 "--- orig/commands.py",
62
 
                 "+++ mod/dommands.py"]
 
61
            "--- orig/commands.py",
 
62
            "+++ mod/dommands.py"]
63
63
        bits = parse_patches(iter(lines), allow_dirty=True)
64
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
65
    def testValidPatchHeader(self):
88
66
        """Parse a valid patch header"""
89
67
        lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
100
78
    def testValidHunkHeader(self):
101
79
        """Parse a valid hunk header"""
102
80
        header = "@@ -34,11 +50,6 @@\n"
103
 
        hunk = hunk_from_header(header)
 
81
        hunk = hunk_from_header(header);
104
82
        self.assertEqual(hunk.orig_pos, 34)
105
83
        self.assertEqual(hunk.orig_range, 11)
106
84
        self.assertEqual(hunk.mod_pos, 50)
110
88
    def testValidHunkHeader2(self):
111
89
        """Parse a tricky, valid hunk header"""
112
90
        header = "@@ -1 +0,0 @@\n"
113
 
        hunk = hunk_from_header(header)
 
91
        hunk = hunk_from_header(header);
114
92
        self.assertEqual(hunk.orig_pos, 1)
115
93
        self.assertEqual(hunk.orig_range, 1)
116
94
        self.assertEqual(hunk.mod_pos, 0)
139
117
        self.makeMalformed("@@ -34,11 +50,6.5 @@\n")
140
118
        self.makeMalformed("@@ -34,11 +50,-6 @@\n")
141
119
 
142
 
    def lineThing(self, text, type):
 
120
    def lineThing(self,text, type):
143
121
        line = parse_line(text)
144
122
        self.assertIsInstance(line, type)
145
123
        self.assertEqual(str(line), text)
168
146
        i = difference_index(patchtext, pstr)
169
147
        if i is not None:
170
148
            print "%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i])
171
 
        self.assertEqual(patchtext, str(patch))
 
149
        self.assertEqual (patchtext, str(patch))
172
150
 
173
151
    def testAll(self):
174
152
        """Test parsing a whole patch"""
183
161
        self.assertContainsRe(patches[0].oldname, '^bar\t')
184
162
        self.assertContainsRe(patches[0].newname, '^qux\t')
185
163
        self.assertContainsRe(str(patches[0]),
186
 
                              'Binary files bar\t.* and qux\t.* differ\n')
 
164
                                  'Binary files bar\t.* and qux\t.* differ\n')
187
165
 
188
166
    def test_parse_binary_after_normal(self):
189
167
        patches = parse_patches(self.data_lines("binary-after-normal.patch"))
192
170
        self.assertContainsRe(patches[1].oldname, '^bar\t')
193
171
        self.assertContainsRe(patches[1].newname, '^qux\t')
194
172
        self.assertContainsRe(str(patches[1]),
195
 
                              'Binary files bar\t.* and qux\t.* differ\n')
 
173
                                  'Binary files bar\t.* and qux\t.* differ\n')
196
174
 
197
175
    def test_roundtrip_binary(self):
198
176
        patchtext = ''.join(self.data_lines("binary.patch"))
250
228
            mod_lines = list(self.datafile(mod))
251
229
 
252
230
            patched_file = IterableFile(iter_patched(orig_lines, patch))
 
231
            lines = []
253
232
            count = 0
254
233
            for patch_line in patched_file:
255
234
                self.assertEqual(patch_line, mod_lines[count])
260
239
        binary_lines = self.data_lines('binary.patch')
261
240
        e = self.assertRaises(BinaryFiles, iter_patched, [], binary_lines)
262
241
 
 
242
 
263
243
    def test_iter_patched_from_hunks(self):
264
244
        """Test a few patch files, and make sure they work."""
265
245
        files = [
276
256
            mod_lines = list(self.datafile(mod))
277
257
            iter_patched = iter_patched_from_hunks(orig_lines, parsed.hunks)
278
258
            patched_file = IterableFile(iter_patched)
 
259
            lines = []
279
260
            count = 0
280
261
            for patch_line in patched_file:
281
262
                self.assertEqual(patch_line, mod_lines[count])