← 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: Patch Queue Manager
  • Date: 2013-05-23 10:35:23 UTC
  • mfrom: (6574.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20130523103523-2wt6jmauja1n1vdt
(jameinel) Merge bzr/2.5 into trunk. (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_diff.py
1
 
# Copyright (C) 2005, 2006 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006-2012 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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.branch import Branch
26
 
from bzrlib import workingtree
27
 
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
    )
28
34
 
29
35
 
30
36
def subst_dates(string):
33
39
                  'YYYY-MM-DD HH:MM:SS +ZZZZ', string)
34
40
 
35
41
 
36
 
class TestDiff(ExternalBase):
37
 
 
38
 
    def make_example_branch(test):
39
 
        # FIXME: copied from test_too_much -- share elsewhere?
40
 
        test.runbzr('init')
41
 
        file('hello', 'wb').write('foo\n')
42
 
        test.runbzr('add hello')
43
 
        test.runbzr('commit -m setup hello')
44
 
        file('goodbye', 'wb').write('baz\n')
45
 
        test.runbzr('add goodbye')
46
 
        test.runbzr('commit -m setup goodbye')
 
42
class DiffBase(tests.TestCaseWithTransport):
 
43
    """Base class with common setup method"""
 
44
 
 
45
    def make_example_branch(self):
 
46
        tree = self.make_branch_and_tree('.')
 
47
        self.build_tree_contents([
 
48
            ('hello', 'foo\n'),
 
49
            ('goodbye', 'baz\n')])
 
50
        tree.add(['hello'])
 
51
        tree.commit('setup')
 
52
        tree.add(['goodbye'])
 
53
        tree.commit('setup')
 
54
        return tree
 
55
 
 
56
 
 
57
class TestDiff(DiffBase):
47
58
 
48
59
    def test_diff(self):
49
 
        self.make_example_branch()
50
 
        file('hello', 'wt').write('hello world!')
51
 
        self.runbzr('commit -m fixing hello')
52
 
        output = self.runbzr('diff -r 2..3', backtick=1, retcode=1)
53
 
        self.assert_('\n+hello world!' in output)
54
 
        output = self.runbzr('diff -r last:3..last:1', backtick=1, retcode=1)
55
 
        self.assert_('\n+baz' in output)
56
 
        file('moo', 'wb').write('moo')
57
 
        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')
58
73
        os.unlink('moo')
59
 
        self.runbzr('diff')
 
74
        self.run_bzr('diff')
60
75
 
61
76
    def test_diff_prefix(self):
62
77
        """diff --prefix appends to filenames in output"""
63
78
        self.make_example_branch()
64
 
        file('hello', 'wb').write('hello world!\n')
65
 
        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)
66
81
        self.assertEquals(err, '')
67
82
        self.assertEqualDiff(subst_dates(out), '''\
68
83
=== modified file 'hello'
74
89
 
75
90
''')
76
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
 
77
98
    def test_diff_p1(self):
78
99
        """diff -p1 produces lkml-style diffs"""
79
100
        self.make_example_branch()
80
 
        file('hello', 'wb').write('hello world!\n')
81
 
        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)
82
103
        self.assertEquals(err, '')
83
104
        self.assertEqualDiff(subst_dates(out), '''\
84
105
=== modified file 'hello'
93
114
    def test_diff_p0(self):
94
115
        """diff -p0 produces diffs with no prefix"""
95
116
        self.make_example_branch()
96
 
        file('hello', 'wb').write('hello world!\n')
97
 
        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)
98
119
        self.assertEquals(err, '')
99
120
        self.assertEqualDiff(subst_dates(out), '''\
100
121
=== modified file 'hello'
110
131
        # Get an error from a file that does not exist at all
111
132
        # (Malone #3619)
112
133
        self.make_example_branch()
113
 
        out, err = self.runbzr('diff does-not-exist', retcode=3)
114
 
        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',))
 
136
 
 
137
    def test_diff_illegal_revision_specifiers(self):
 
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:")
115
159
 
116
160
    def test_diff_unversioned(self):
117
161
        # Get an error when diffing a non-versioned file.
118
162
        # (Malone #3619)
119
163
        self.make_example_branch()
120
164
        self.build_tree(['unversioned-file'])
121
 
        out, err = self.runbzr('diff unversioned-file', retcode=3)
 
165
        out, err = self.run_bzr('diff unversioned-file', retcode=3)
122
166
        self.assertContainsRe(err, 'not versioned.*unversioned-file')
123
167
 
124
168
    # TODO: What should diff say for a file deleted in working tree?
125
169
 
126
170
    def example_branches(self):
127
 
        self.build_tree(['branch1/', 'branch1/file'], line_endings='binary')
128
 
        self.capture('init branch1')
129
 
        self.capture('add branch1/file')
130
 
        self.run_bzr_captured(['commit', '-m', 'add file', 'branch1'])
131
 
        self.capture('branch branch1 branch2')
132
 
        print >> open('branch2/file', 'wb'), 'new content'
133
 
        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
134
181
 
135
 
    def test_diff_branches(self):
136
 
        self.example_branches()
137
 
        # should open branch1 and diff against branch2, 
138
 
        out, err = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 
139
 
                                          'branch1'],
140
 
                                         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)
141
185
        self.assertEquals('', err)
142
186
        self.assertEquals("=== modified file 'file'\n"
143
187
                          "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
146
190
                          "-new content\n"
147
191
                          "+contents of branch1/file\n"
148
192
                          "\n", subst_dates(out))
149
 
        out, ett = self.run_bzr_captured(['diff', 'branch2', 'branch1'],
150
 
                                         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)
151
197
        self.assertEquals('', err)
152
198
        self.assertEqualDiff("=== modified file 'file'\n"
153
199
                              "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
154
200
                              "+++ file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
155
201
                              "@@ -1,1 +1,1 @@\n"
156
 
                              "-new content\n"
157
 
                              "+contents of branch1/file\n"
 
202
                              "-contents of branch1/file\n"
 
203
                              "+new content\n"
158
204
                              "\n", subst_dates(out))
159
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
 
160
250
    def test_diff_revno_branches(self):
161
251
        self.example_branches()
162
 
        print >> open('branch2/file', 'wb'), 'even newer content'
163
 
        self.run_bzr_captured(['commit', '-m', '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')
164
255
 
165
 
        out, err = self.run_bzr_captured(['diff', '-r', 'revno:1:branch2..revno:1:branch1'],
166
 
                                         retcode=0)
 
256
        out, err = self.run_bzr('diff -r revno:1:branch2..revno:1:branch1',
 
257
                                )
167
258
        self.assertEquals('', err)
168
259
        self.assertEquals('', out)
169
 
        out, ett = self.run_bzr_captured(['diff', '-r', 'revno:2:branch2..revno:1:branch1'],
170
 
                                         retcode=1)
 
260
        out, err = self.run_bzr('diff -r revno:2:branch2..revno:1:branch1',
 
261
                                retcode=1)
171
262
        self.assertEquals('', err)
172
263
        self.assertEqualDiff("=== modified file 'file'\n"
173
264
                              "--- file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
178
269
                              "\n", subst_dates(out))
179
270
 
180
271
    def example_branch2(self):
181
 
        self.build_tree(['branch1/', 'branch1/file1'], line_endings='binary')
182
 
        self.capture('init branch1')
183
 
        self.capture('add branch1/file1')
184
 
        print >> open('branch1/file1', 'wb'), 'original line'
185
 
        self.run_bzr_captured(['commit', '-m', 'first commit', 'branch1'])
186
 
        
187
 
        print >> open('branch1/file1', 'wb'), 'repo line'
188
 
        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
189
279
 
190
280
    def test_diff_to_working_tree(self):
191
281
        self.example_branch2()
192
 
        
193
 
        print >> open('branch1/file1', 'wb'), 'new line'
194
 
        output = self.run_bzr_captured(['diff', '-r', '1..', 'branch1'], retcode=1)
195
 
        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')
196
293
 
197
294
    def test_diff_across_rename(self):
198
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")
199
320
        self.make_example_branch()
200
 
        self.run_bzr('diff', '-r', '0..1', 'hello', retcode=1)
201
 
        wt = workingtree.WorkingTree.open_containing('.')[0]
202
 
        wt.rename_one('hello', 'hello1')
203
 
        self.run_bzr('diff', 'hello1', retcode=1)
204
 
        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])
205
326
 
206
327
 
207
328
class TestCheckoutDiff(TestDiff):
208
329
 
209
330
    def make_example_branch(self):
210
 
        super(TestCheckoutDiff, self).make_example_branch()
211
 
        self.runbzr('checkout . checkout')
 
331
        tree = super(TestCheckoutDiff, self).make_example_branch()
 
332
        tree = tree.branch.create_checkout('checkout')
212
333
        os.chdir('checkout')
 
334
        return tree
213
335
 
214
336
    def example_branch2(self):
215
 
        super(TestCheckoutDiff, self).example_branch2()
 
337
        tree = super(TestCheckoutDiff, self).example_branch2()
216
338
        os.mkdir('checkouts')
217
 
        self.runbzr('checkout branch1 checkouts/branch1')
 
339
        tree = tree.branch.create_checkout('checkouts/branch1')
218
340
        os.chdir('checkouts')
 
341
        return tree
219
342
 
220
343
    def example_branches(self):
221
 
        super(TestCheckoutDiff, self).example_branches()
 
344
        branch1_tree, branch2_tree = super(TestCheckoutDiff,
 
345
                                           self).example_branches()
222
346
        os.mkdir('checkouts')
223
 
        self.runbzr('checkout branch1 checkouts/branch1')
224
 
        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')
225
349
        os.chdir('checkouts')
226
 
 
227
 
 
228
 
class TestDiffLabels(TestDiff):
 
350
        return branch1_tree, branch2_tree
 
351
 
 
352
 
 
353
class TestDiffLabels(DiffBase):
229
354
 
230
355
    def test_diff_label_removed(self):
231
 
        super(TestDiffLabels, self).make_example_branch()
232
 
        self.runbzr('remove hello')
233
 
        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)
234
359
        self.assertTrue("=== removed file 'hello'" in diff[0])
235
360
 
236
361
    def test_diff_label_added(self):
237
 
        super(TestDiffLabels, self).make_example_branch()
238
 
        file('barbar', 'wt').write('barbar')
239
 
        self.runbzr('add barbar')
240
 
        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)
241
366
        self.assertTrue("=== added file 'barbar'" in diff[0])
242
367
 
243
368
    def test_diff_label_modified(self):
244
369
        super(TestDiffLabels, self).make_example_branch()
245
 
        file('hello', 'wt').write('barbar')
246
 
        diff = self.run_bzr_captured(['diff'], retcode=1)
 
370
        self.build_tree_contents([('hello', 'barbar')])
 
371
        diff = self.run_bzr('diff', retcode=1)
247
372
        self.assertTrue("=== modified file 'hello'" in diff[0])
248
373
 
249
374
    def test_diff_label_renamed(self):
250
 
        super(TestDiffLabels, self).make_example_branch()
251
 
        self.runbzr('rename hello gruezi')
252
 
        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)
253
378
        self.assertTrue("=== renamed file 'hello' => 'gruezi'" in diff[0])
 
379
 
 
380
 
 
381
class TestExternalDiff(DiffBase):
 
382
 
 
383
    def test_external_diff(self):
 
384
        """Test that we can spawn an external diff process"""
 
385
        self.disable_missing_extensions_warning()
 
386
        # We have to use run_bzr_subprocess, because we need to
 
387
        # test writing directly to stdout, (there was a bug in
 
388
        # subprocess.py that we had to workaround).
 
389
        # However, if 'diff' may not be available
 
390
        self.make_example_branch()
 
391
        out, err = self.run_bzr_subprocess(
 
392
            'diff -Oprogress_bar=none -r 1 --diff-options -ub',
 
393
            universal_newlines=True,
 
394
            retcode=None)
 
395
        if 'Diff is not installed on this machine' in err:
 
396
            raise tests.TestSkipped("No external 'diff' is available")
 
397
        self.assertEqual('', err)
 
398
        # We have to skip the stuff in the middle, because it depends
 
399
        # on time.time()
 
400
        self.assertStartsWith(out, "=== added file 'goodbye'\n"
 
401
                                   "--- goodbye\t1970-01-01 00:00:00 +0000\n"
 
402
                                   "+++ goodbye\t")
 
403
        self.assertEndsWith(out, "\n@@ -0,0 +1 @@\n"
 
404
                                 "+baz\n\n")
 
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
 
 
416
 
 
417
class TestDiffOutput(DiffBase):
 
418
 
 
419
    def test_diff_output(self):
 
420
        # check that output doesn't mangle line-endings
 
421
        self.make_example_branch()
 
422
        self.build_tree_contents([('hello', 'hello world!\n')])
 
423
        output = self.run_bzr_subprocess('diff', retcode=1)[0]
 
424
        self.assert_('\n+hello world!\n' in output)