/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_patches.py

  • Committer: Vincent Ladeuil
  • Date: 2012-01-18 14:09:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120118140919-rlvdrhpc0nq1lbwi
Change set/remove to require a lock for the branch config files.

This means that tests (or any plugin for that matter) do not requires an
explicit lock on the branch anymore to change a single option. This also
means the optimisation becomes "opt-in" and as such won't be as
spectacular as it may be and/or harder to get right (nothing fails
anymore).

This reduces the diff by ~300 lines.

Code/tests that were updating more than one config option is still taking
a lock to at least avoid some IOs and demonstrate the benefits through
the decreased number of hpss calls.

The duplication between BranchStack and BranchOnlyStack will be removed
once the same sharing is in place for local config files, at which point
the Stack class itself may be able to host the changes.

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])