← 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: Canonical.com Patch Queue Manager
  • Date: 2011-05-04 12:10:51 UTC
  • mfrom: (5819.1.4 777007-developer-doc)
  • Revision ID: pqm@pqm.ubuntu.com-20110504121051-aovlsmqiivjmc4fc
(jelmer) Small fixes to developer documentation. (Jonathan Riddell)

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