← 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: John Arbash Meinel
  • Date: 2010-02-16 16:08:40 UTC
  • mfrom: (4797.2.15 2.1)
  • mto: (4797.2.16 2.1)
  • mto: This revision was merged to the branch mainline in revision 5037.
  • Revision ID: john@arbash-meinel.com-20100216160840-xwbpuu0v89gq8lej
Tags: bzr-2.1.0
bring in the latest 2.1 changes

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