← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_diff.py

  • Committer: Vincent Ladeuil
  • Date: 2013-10-04 09:56:23 UTC
  • mto: (6588.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6589.
  • Revision ID: v.ladeuil+lp@free.fr-20131004095623-xlan34vg0y51gdb5
https://launchpad.net/bugs/1235099
Stricter checks on configuration option names

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_diff.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2012 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
"""Black-box tests for bzr diff.
19
 
"""
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
"""Black-box tests for bzr diff."""
20
19
 
21
20
import os
22
21
import re
23
22
 
24
 
import bzrlib
25
 
from bzrlib import workingtree
26
 
from bzrlib.branch import Branch
27
 
from bzrlib.tests import TestSkipped
28
 
from bzrlib.tests.blackbox import ExternalBase
 
23
from bzrlib import (
 
24
    tests,
 
25
    workingtree,
 
26
    )
 
27
from bzrlib.diff import (
 
28
    DiffTree,
 
29
    format_registry as diff_format_registry,
 
30
    )
 
31
from bzrlib.tests import (
 
32
    features,
 
33
    )
29
34
 
30
35
 
31
36
def subst_dates(string):
34
39
                  'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
35
40
 
36
41
 
37
 
class DiffBase(ExternalBase):
 
42
class DiffBase(tests.TestCaseWithTransport):
38
43
    """Base class with common setup method"""
39
44
 
40
45
    def make_example_branch(self):
41
 
        # FIXME: copied from test_too_much -- share elsewhere?
42
46
        tree = self.make_branch_and_tree('.')
43
 
        open('hello', 'wb').write('foo\n')
 
47
        self.build_tree_contents([
 
48
            ('hello', 'foo\n'),
 
49
            ('goodbye', 'baz\n')])
44
50
        tree.add(['hello'])
45
51
        tree.commit('setup')
46
 
        open('goodbye', 'wb').write('baz\n')
47
52
        tree.add(['goodbye'])
48
53
        tree.commit('setup')
 
54
        return tree
49
55
 
50
56
 
51
57
class TestDiff(DiffBase):
52
58
 
53
59
    def test_diff(self):
54
 
        self.make_example_branch()
55
 
        file('hello', 'wt').write('hello world!')
56
 
        self.runbzr('commit -m fixing hello')
57
 
        output = self.runbzr('diff -r 2..3', backtick=1, retcode=1)
58
 
        self.assert_('\n+hello world!' in output)
59
 
        output = self.runbzr('diff -r last:3..last:1', backtick=1, retcode=1)
60
 
        self.assert_('\n+baz' in output)
61
 
        file('moo', 'wb').write('moo')
62
 
        self.runbzr('add moo')
 
60
        tree = self.make_example_branch()
 
61
        self.build_tree_contents([('hello', 'hello world!')])
 
62
        tree.commit(message='fixing hello')
 
63
        output = self.run_bzr('diff -r 2..3', retcode=1)[0]
 
64
        self.assert_('\n+hello world!' in output)
 
65
        output = self.run_bzr('diff -c 3', retcode=1)[0]
 
66
        self.assert_('\n+hello world!' in output)
 
67
        output = self.run_bzr('diff -r last:3..last:1', retcode=1)[0]
 
68
        self.assert_('\n+baz' in output)
 
69
        output = self.run_bzr('diff -c last:2', retcode=1)[0]
 
70
        self.assert_('\n+baz' in output)
 
71
        self.build_tree(['moo'])
 
72
        tree.add('moo')
63
73
        os.unlink('moo')
64
 
        self.runbzr('diff')
 
74
        self.run_bzr('diff')
65
75
 
66
76
    def test_diff_prefix(self):
67
77
        """diff --prefix appends to filenames in output"""
68
78
        self.make_example_branch()
69
 
        file('hello', 'wb').write('hello world!\n')
70
 
        out, err = self.runbzr('diff --prefix old/:new/', retcode=1)
 
79
        self.build_tree_contents([('hello', 'hello world!\n')])
 
80
        out, err = self.run_bzr('diff --prefix old/:new/', retcode=1)
71
81
        self.assertEquals(err, '')
72
82
        self.assertEqualDiff(subst_dates(out), '''\
73
83
=== modified file 'hello'
79
89
 
80
90
''')
81
91
 
 
92
    def test_diff_illegal_prefix_value(self):
 
93
        # There was an error in error reporting for this option
 
94
        out, err = self.run_bzr('diff --prefix old/', retcode=3)
 
95
        self.assertContainsRe(err,
 
96
            '--prefix expects two values separated by a colon')
 
97
 
82
98
    def test_diff_p1(self):
83
99
        """diff -p1 produces lkml-style diffs"""
84
100
        self.make_example_branch()
85
 
        file('hello', 'wb').write('hello world!\n')
86
 
        out, err = self.runbzr('diff -p1', retcode=1)
 
101
        self.build_tree_contents([('hello', 'hello world!\n')])
 
102
        out, err = self.run_bzr('diff -p1', retcode=1)
87
103
        self.assertEquals(err, '')
88
104
        self.assertEqualDiff(subst_dates(out), '''\
89
105
=== modified file 'hello'
98
114
    def test_diff_p0(self):
99
115
        """diff -p0 produces diffs with no prefix"""
100
116
        self.make_example_branch()
101
 
        file('hello', 'wb').write('hello world!\n')
102
 
        out, err = self.runbzr('diff -p0', retcode=1)
 
117
        self.build_tree_contents([('hello', 'hello world!\n')])
 
118
        out, err = self.run_bzr('diff -p0', retcode=1)
103
119
        self.assertEquals(err, '')
104
120
        self.assertEqualDiff(subst_dates(out), '''\
105
121
=== modified file 'hello'
115
131
        # Get an error from a file that does not exist at all
116
132
        # (Malone #3619)
117
133
        self.make_example_branch()
118
 
        out, err = self.runbzr('diff does-not-exist', retcode=3)
119
 
        self.assertContainsRe(err, 'not versioned.*does-not-exist')
 
134
        out, err = self.run_bzr('diff does-not-exist', retcode=3,
 
135
            error_regexes=('not versioned.*does-not-exist',))
120
136
 
121
137
    def test_diff_illegal_revision_specifiers(self):
122
 
        out, err = self.runbzr('diff -r 1..23..123', retcode=3)
123
 
        self.assertContainsRe(err, 'one or two revision specifiers')
 
138
        out, err = self.run_bzr('diff -r 1..23..123', retcode=3,
 
139
            error_regexes=('one or two revision specifiers',))
 
140
 
 
141
    def test_diff_using_and_format(self):
 
142
        out, err = self.run_bzr('diff --format=default --using=mydi', retcode=3,
 
143
            error_regexes=('are mutually exclusive',))
 
144
 
 
145
    def test_diff_nonexistent_revision(self):
 
146
        out, err = self.run_bzr('diff -r 123', retcode=3,
 
147
            error_regexes=("Requested revision: '123' does not "
 
148
                "exist in branch:",))
 
149
 
 
150
    def test_diff_nonexistent_dotted_revision(self):
 
151
        out, err = self.run_bzr('diff -r 1.1', retcode=3)
 
152
        self.assertContainsRe(err,
 
153
            "Requested revision: '1.1' does not exist in branch:")
 
154
 
 
155
    def test_diff_nonexistent_dotted_revision_change(self):
 
156
        out, err = self.run_bzr('diff -c 1.1', retcode=3)
 
157
        self.assertContainsRe(err,
 
158
            "Requested revision: '1.1' does not exist in branch:")
124
159
 
125
160
    def test_diff_unversioned(self):
126
161
        # Get an error when diffing a non-versioned file.
127
162
        # (Malone #3619)
128
163
        self.make_example_branch()
129
164
        self.build_tree(['unversioned-file'])
130
 
        out, err = self.runbzr('diff unversioned-file', retcode=3)
 
165
        out, err = self.run_bzr('diff unversioned-file', retcode=3)
131
166
        self.assertContainsRe(err, 'not versioned.*unversioned-file')
132
167
 
133
168
    # TODO: What should diff say for a file deleted in working tree?
134
169
 
135
170
    def example_branches(self):
136
 
        self.build_tree(['branch1/', 'branch1/file'], line_endings='binary')
137
 
        self.capture('init branch1')
138
 
        self.capture('add branch1/file')
139
 
        self.run_bzr_captured(['commit', '-m', 'add file', 'branch1'])
140
 
        self.capture('branch branch1 branch2')
141
 
        print >> open('branch2/file', 'wb'), 'new content'
142
 
        self.run_bzr_captured(['commit', '-m', 'update file', 'branch2'])
 
171
        branch1_tree = self.make_branch_and_tree('branch1')
 
172
        self.build_tree(['branch1/file'], line_endings='binary')
 
173
        self.build_tree(['branch1/file2'], line_endings='binary')
 
174
        branch1_tree.add('file')
 
175
        branch1_tree.add('file2')
 
176
        branch1_tree.commit(message='add file and file2')
 
177
        branch2_tree = branch1_tree.bzrdir.sprout('branch2').open_workingtree()
 
178
        self.build_tree_contents([('branch2/file', 'new content\n')])
 
179
        branch2_tree.commit(message='update file')
 
180
        return branch1_tree, branch2_tree
143
181
 
144
 
    def test_diff_branches(self):
145
 
        self.example_branches()
146
 
        # should open branch1 and diff against branch2, 
147
 
        out, err = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 
148
 
                                          'branch1'],
149
 
                                         retcode=1)
 
182
    def check_b2_vs_b1(self, cmd):
 
183
        # Compare branch2 vs branch1 using cmd and check the result
 
184
        out, err = self.run_bzr(cmd, retcode=1)
150
185
        self.assertEquals('', err)
151
186
        self.assertEquals("=== modified file 'file'\n"
152
187
                          "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
155
190
                          "-new content\n"
156
191
                          "+contents of branch1/file\n"
157
192
                          "\n", subst_dates(out))
158
 
        out, err = self.run_bzr_captured(['diff', 'branch2', 'branch1'],
159
 
                                         retcode=1)
 
193
 
 
194
    def check_b1_vs_b2(self, cmd):
 
195
        # Compare branch1 vs branch2 using cmd and check the result
 
196
        out, err = self.run_bzr(cmd, retcode=1)
160
197
        self.assertEquals('', err)
161
198
        self.assertEqualDiff("=== modified file 'file'\n"
162
199
                              "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
163
200
                              "+++ file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
164
201
                              "@@ -1,1 +1,1 @@\n"
165
 
                              "-new content\n"
166
 
                              "+contents of branch1/file\n"
 
202
                              "-contents of branch1/file\n"
 
203
                              "+new content\n"
167
204
                              "\n", subst_dates(out))
168
205
 
 
206
    def check_no_diffs(self, cmd):
 
207
        # Check that running cmd returns an empty diff
 
208
        out, err = self.run_bzr(cmd, retcode=0)
 
209
        self.assertEquals('', err)
 
210
        self.assertEquals('', out)
 
211
 
 
212
    def test_diff_branches(self):
 
213
        self.example_branches()
 
214
        # should open branch1 and diff against branch2,
 
215
        self.check_b2_vs_b1('diff -r branch:branch2 branch1')
 
216
        # Compare two working trees using various syntax forms
 
217
        self.check_b2_vs_b1('diff --old branch2 --new branch1')
 
218
        self.check_b2_vs_b1('diff --old branch2 branch1')
 
219
        self.check_b2_vs_b1('diff branch2 --new branch1')
 
220
        # Test with a selected file that was changed
 
221
        self.check_b2_vs_b1('diff --old branch2 --new branch1 file')
 
222
        self.check_b2_vs_b1('diff --old branch2 branch1/file')
 
223
        self.check_b2_vs_b1('diff branch2/file --new branch1')
 
224
        # Test with a selected file that was not changed
 
225
        self.check_no_diffs('diff --old branch2 --new branch1 file2')
 
226
        self.check_no_diffs('diff --old branch2 branch1/file2')
 
227
        self.check_no_diffs('diff branch2/file2 --new branch1')
 
228
 
 
229
    def test_diff_branches_no_working_trees(self):
 
230
        branch1_tree, branch2_tree = self.example_branches()
 
231
        # Compare a working tree to a branch without a WT
 
232
        dir1 = branch1_tree.bzrdir
 
233
        dir1.destroy_workingtree()
 
234
        self.assertFalse(dir1.has_workingtree())
 
235
        self.check_b2_vs_b1('diff --old branch2 --new branch1')
 
236
        self.check_b2_vs_b1('diff --old branch2 branch1')
 
237
        self.check_b2_vs_b1('diff branch2 --new branch1')
 
238
        # Compare a branch without a WT to one with a WT
 
239
        self.check_b1_vs_b2('diff --old branch1 --new branch2')
 
240
        self.check_b1_vs_b2('diff --old branch1 branch2')
 
241
        self.check_b1_vs_b2('diff branch1 --new branch2')
 
242
        # Compare a branch with a WT against another without a WT
 
243
        dir2 = branch2_tree.bzrdir
 
244
        dir2.destroy_workingtree()
 
245
        self.assertFalse(dir2.has_workingtree())
 
246
        self.check_b1_vs_b2('diff --old branch1 --new branch2')
 
247
        self.check_b1_vs_b2('diff --old branch1 branch2')
 
248
        self.check_b1_vs_b2('diff branch1 --new branch2')
 
249
 
169
250
    def test_diff_revno_branches(self):
170
251
        self.example_branches()
171
 
        print >> open('branch2/file', 'wb'), 'even newer content'
172
 
        self.run_bzr_captured(['commit', '-m', 
173
 
                               'update file once more', 'branch2'])
 
252
        branch2_tree = workingtree.WorkingTree.open_containing('branch2')[0]
 
253
        self.build_tree_contents([('branch2/file', 'even newer content')])
 
254
        branch2_tree.commit(message='update file once more')
174
255
 
175
 
        out, err = self.run_bzr_captured(['diff', '-r',
176
 
                                          'revno:1:branch2..revno:1:branch1'],
177
 
                                         retcode=0)
 
256
        out, err = self.run_bzr('diff -r revno:1:branch2..revno:1:branch1',
 
257
                                )
178
258
        self.assertEquals('', err)
179
259
        self.assertEquals('', out)
180
 
        out, err = self.run_bzr_captured(['diff', '-r', 
181
 
                                          'revno:2:branch2..revno:1:branch1'],
182
 
                                         retcode=1)
 
260
        out, err = self.run_bzr('diff -r revno:2:branch2..revno:1:branch1',
 
261
                                retcode=1)
183
262
        self.assertEquals('', err)
184
263
        self.assertEqualDiff("=== modified file 'file'\n"
185
264
                              "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
190
269
                              "\n", subst_dates(out))
191
270
 
192
271
    def example_branch2(self):
193
 
        self.build_tree(['branch1/', 'branch1/file1'], line_endings='binary')
194
 
        self.capture('init branch1')
195
 
        self.capture('add branch1/file1')
196
 
        print >> open('branch1/file1', 'wb'), 'original line'
197
 
        self.run_bzr_captured(['commit', '-m', 'first commit', 'branch1'])
198
 
        
199
 
        print >> open('branch1/file1', 'wb'), 'repo line'
200
 
        self.run_bzr_captured(['commit', '-m', 'second commit', 'branch1'])
 
272
        branch1_tree = self.make_branch_and_tree('branch1')
 
273
        self.build_tree_contents([('branch1/file1', 'original line\n')])
 
274
        branch1_tree.add('file1')
 
275
        branch1_tree.commit(message='first commit')
 
276
        self.build_tree_contents([('branch1/file1', 'repo line\n')])
 
277
        branch1_tree.commit(message='second commit')
 
278
        return branch1_tree
201
279
 
202
280
    def test_diff_to_working_tree(self):
203
281
        self.example_branch2()
204
 
        
205
 
        print >> open('branch1/file1', 'wb'), 'new line'
206
 
        output = self.run_bzr_captured(['diff', '-r', '1..', 'branch1'],
207
 
                                       retcode=1)
208
 
        self.assertTrue('\n-original line\n+new line\n' in output[0])
 
282
        self.build_tree_contents([('branch1/file1', 'new line')])
 
283
        output = self.run_bzr('diff -r 1.. branch1', retcode=1)
 
284
        self.assertContainsRe(output[0], '\n\\-original line\n\\+new line\n')
 
285
 
 
286
    def test_diff_to_working_tree_in_subdir(self):
 
287
        self.example_branch2()
 
288
        self.build_tree_contents([('branch1/file1', 'new line')])
 
289
        os.mkdir('branch1/dir1')
 
290
        output = self.run_bzr('diff -r 1..', retcode=1,
 
291
                              working_dir='branch1/dir1')
 
292
        self.assertContainsRe(output[0], '\n\\-original line\n\\+new line\n')
209
293
 
210
294
    def test_diff_across_rename(self):
211
295
        """The working tree path should always be considered for diffing"""
 
296
        tree = self.make_example_branch()
 
297
        self.run_bzr('diff -r 0..1 hello', retcode=1)
 
298
        tree.rename_one('hello', 'hello1')
 
299
        self.run_bzr('diff hello1', retcode=1)
 
300
        self.run_bzr('diff -r 0..1 hello1', retcode=1)
 
301
 
 
302
    def test_diff_to_branch_no_working_tree(self):
 
303
        branch1_tree = self.example_branch2()
 
304
        dir1 = branch1_tree.bzrdir
 
305
        dir1.destroy_workingtree()
 
306
        self.assertFalse(dir1.has_workingtree())
 
307
        output = self.run_bzr('diff -r 1.. branch1', retcode=1)
 
308
        self.assertContainsRe(output[0], '\n\\-original line\n\\+repo line\n')
 
309
 
 
310
    def test_custom_format(self):
 
311
        class BooDiffTree(DiffTree):
 
312
 
 
313
            def show_diff(self, specific_files, extra_trees=None):
 
314
                self.to_file.write("BOO!\n")
 
315
                return super(BooDiffTree, self).show_diff(specific_files,
 
316
                    extra_trees)
 
317
 
 
318
        diff_format_registry.register("boo", BooDiffTree, "Scary diff format")
 
319
        self.addCleanup(diff_format_registry.remove, "boo")
212
320
        self.make_example_branch()
213
 
        self.run_bzr('diff', '-r', '0..1', 'hello', retcode=1)
214
 
        wt = workingtree.WorkingTree.open_containing('.')[0]
215
 
        wt.rename_one('hello', 'hello1')
216
 
        self.run_bzr('diff', 'hello1', retcode=1)
217
 
        self.run_bzr('diff', '-r', '0..1', 'hello1', retcode=1)
 
321
        self.build_tree_contents([('hello', 'hello world!\n')])
 
322
        output = self.run_bzr('diff --format=boo', retcode=1)
 
323
        self.assertTrue("BOO!" in output[0])
 
324
        output = self.run_bzr('diff -Fboo', retcode=1)
 
325
        self.assertTrue("BOO!" in output[0])
218
326
 
219
327
 
220
328
class TestCheckoutDiff(TestDiff):
221
329
 
222
330
    def make_example_branch(self):
223
 
        super(TestCheckoutDiff, self).make_example_branch()
224
 
        self.runbzr('checkout . checkout')
 
331
        tree = super(TestCheckoutDiff, self).make_example_branch()
 
332
        tree = tree.branch.create_checkout('checkout')
225
333
        os.chdir('checkout')
 
334
        return tree
226
335
 
227
336
    def example_branch2(self):
228
 
        super(TestCheckoutDiff, self).example_branch2()
 
337
        tree = super(TestCheckoutDiff, self).example_branch2()
229
338
        os.mkdir('checkouts')
230
 
        self.runbzr('checkout branch1 checkouts/branch1')
 
339
        tree = tree.branch.create_checkout('checkouts/branch1')
231
340
        os.chdir('checkouts')
 
341
        return tree
232
342
 
233
343
    def example_branches(self):
234
 
        super(TestCheckoutDiff, self).example_branches()
 
344
        branch1_tree, branch2_tree = super(TestCheckoutDiff,
 
345
                                           self).example_branches()
235
346
        os.mkdir('checkouts')
236
 
        self.runbzr('checkout branch1 checkouts/branch1')
237
 
        self.runbzr('checkout branch2 checkouts/branch2')
 
347
        branch1_tree = branch1_tree.branch.create_checkout('checkouts/branch1')
 
348
        branch2_tree = branch2_tree.branch.create_checkout('checkouts/branch2')
238
349
        os.chdir('checkouts')
 
350
        return branch1_tree, branch2_tree
239
351
 
240
352
 
241
353
class TestDiffLabels(DiffBase):
242
354
 
243
355
    def test_diff_label_removed(self):
244
 
        super(TestDiffLabels, self).make_example_branch()
245
 
        self.runbzr('remove hello')
246
 
        diff = self.run_bzr_captured(['diff'], retcode=1)
 
356
        tree = super(TestDiffLabels, self).make_example_branch()
 
357
        tree.remove('hello', keep_files=False)
 
358
        diff = self.run_bzr('diff', retcode=1)
247
359
        self.assertTrue("=== removed file 'hello'" in diff[0])
248
360
 
249
361
    def test_diff_label_added(self):
250
 
        super(TestDiffLabels, self).make_example_branch()
251
 
        file('barbar', 'wt').write('barbar')
252
 
        self.runbzr('add barbar')
253
 
        diff = self.run_bzr_captured(['diff'], retcode=1)
 
362
        tree = super(TestDiffLabels, self).make_example_branch()
 
363
        self.build_tree_contents([('barbar', 'barbar')])
 
364
        tree.add('barbar')
 
365
        diff = self.run_bzr('diff', retcode=1)
254
366
        self.assertTrue("=== added file 'barbar'" in diff[0])
255
367
 
256
368
    def test_diff_label_modified(self):
257
369
        super(TestDiffLabels, self).make_example_branch()
258
 
        file('hello', 'wt').write('barbar')
259
 
        diff = self.run_bzr_captured(['diff'], retcode=1)
 
370
        self.build_tree_contents([('hello', 'barbar')])
 
371
        diff = self.run_bzr('diff', retcode=1)
260
372
        self.assertTrue("=== modified file 'hello'" in diff[0])
261
373
 
262
374
    def test_diff_label_renamed(self):
263
 
        super(TestDiffLabels, self).make_example_branch()
264
 
        self.runbzr('rename hello gruezi')
265
 
        diff = self.run_bzr_captured(['diff'], retcode=1)
 
375
        tree = super(TestDiffLabels, self).make_example_branch()
 
376
        tree.rename_one('hello', 'gruezi')
 
377
        diff = self.run_bzr('diff', retcode=1)
266
378
        self.assertTrue("=== renamed file 'hello' => 'gruezi'" in diff[0])
267
379
 
268
380
 
270
382
 
271
383
    def test_external_diff(self):
272
384
        """Test that we can spawn an external diff process"""
 
385
        self.disable_missing_extensions_warning()
273
386
        # We have to use run_bzr_subprocess, because we need to
274
387
        # test writing directly to stdout, (there was a bug in
275
388
        # subprocess.py that we had to workaround).
276
389
        # However, if 'diff' may not be available
277
390
        self.make_example_branch()
278
 
        orig_progress = os.environ.get('BZR_PROGRESS_BAR')
279
 
        try:
280
 
            os.environ['BZR_PROGRESS_BAR'] = 'none'
281
 
            out, err = self.run_bzr_subprocess('diff', '-r', '1',
282
 
                                               '--diff-options', '-ub',
283
 
                                               universal_newlines=True,
284
 
                                               retcode=None)
285
 
        finally:
286
 
            if orig_progress is None:
287
 
                del os.environ['BZR_PROGRESS_BAR']
288
 
            else:
289
 
                os.environ['BZR_PROGRESS_BAR'] = orig_progress
290
 
            
 
391
        out, err = self.run_bzr_subprocess(
 
392
            'diff -Oprogress_bar=none -r 1 --diff-options -ub',
 
393
            universal_newlines=True,
 
394
            retcode=None)
291
395
        if 'Diff is not installed on this machine' in err:
292
 
            raise TestSkipped("No external 'diff' is available")
 
396
            raise tests.TestSkipped("No external 'diff' is available")
293
397
        self.assertEqual('', err)
294
398
        # We have to skip the stuff in the middle, because it depends
295
399
        # on time.time()
299
403
        self.assertEndsWith(out, "\n@@ -0,0 +1 @@\n"
300
404
                                 "+baz\n\n")
301
405
 
 
406
    def test_external_diff_options_and_using(self):
 
407
        """Test that the options are passed correctly to an external diff process"""
 
408
        self.requireFeature(features.diff_feature)
 
409
        self.make_example_branch()
 
410
        self.build_tree_contents([('hello', 'Foo\n')])
 
411
        out, err = self.run_bzr('diff --diff-options -i --using diff',
 
412
                                    retcode=1)
 
413
        self.assertEquals("=== modified file 'hello'\n", out)
 
414
        self.assertEquals('', err)
 
415
 
302
416
 
303
417
class TestDiffOutput(DiffBase):
304
418
 
305
419
    def test_diff_output(self):
306
420
        # check that output doesn't mangle line-endings
307
421
        self.make_example_branch()
308
 
        file('hello', 'wb').write('hello world!\n')
 
422
        self.build_tree_contents([('hello', 'hello world!\n')])
309
423
        output = self.run_bzr_subprocess('diff', retcode=1)[0]
310
424
        self.assert_('\n+hello world!\n' in output)