/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/tests/test_diff.py

  • Committer: Jelmer Vernooij
  • Date: 2017-10-27 09:03:47 UTC
  • mfrom: (6798.1.1 escaping)
  • Revision ID: jelmer@jelmer.uk-20171027090347-yxa0xg7rwftar05a
Merge lp:~jelmer/brz/escaping.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_diff.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2014, 2016, 2017 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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
18
 
from cStringIO import StringIO
19
18
import subprocess
20
 
import sys
21
19
import tempfile
22
20
 
23
 
from bzrlib import (
 
21
from .. import (
24
22
    diff,
25
23
    errors,
26
24
    osutils,
32
30
    tests,
33
31
    transform,
34
32
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import test_win32utils
37
 
 
38
 
 
39
 
class _AttribFeature(tests.Feature):
40
 
 
41
 
    def _probe(self):
42
 
        if (sys.platform not in ('cygwin', 'win32')):
43
 
            return False
44
 
        try:
45
 
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
46
 
        except OSError, e:
47
 
            return False
48
 
        return (0 == proc.wait())
49
 
 
50
 
    def feature_name(self):
51
 
        return 'attrib Windows command-line tool'
52
 
 
53
 
AttribFeature = _AttribFeature()
54
 
 
55
 
 
56
 
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
57
 
                                    'bzrlib._patiencediff_c')
 
33
from ..sixish import (
 
34
    BytesIO,
 
35
    )
 
36
from ..tests import (
 
37
    features,
 
38
    EncodingAdapter,
 
39
    )
 
40
from ..tests.blackbox.test_diff import subst_dates
 
41
from ..tests.scenarios import load_tests_apply_scenarios
 
42
 
 
43
 
 
44
load_tests = load_tests_apply_scenarios
58
45
 
59
46
 
60
47
def udiff_lines(old, new, allow_binary=False):
61
 
    output = StringIO()
 
48
    output = BytesIO()
62
49
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
63
50
    output.seek(0, 0)
64
51
    return output.readlines()
66
53
 
67
54
def external_udiff_lines(old, new, use_stringio=False):
68
55
    if use_stringio:
69
 
        # StringIO has no fileno, so it tests a different codepath
70
 
        output = StringIO()
 
56
        # BytesIO has no fileno, so it tests a different codepath
 
57
        output = BytesIO()
71
58
    else:
72
59
        output = tempfile.TemporaryFile()
73
60
    try:
80
67
    return lines
81
68
 
82
69
 
 
70
class StubO(object):
 
71
    """Simple file-like object that allows writes with any type and records."""
 
72
 
 
73
    def __init__(self):
 
74
        self.write_record = []
 
75
 
 
76
    def write(self, data):
 
77
        self.write_record.append(data)
 
78
 
 
79
    def check_types(self, testcase, expected_type):
 
80
        testcase.assertFalse(
 
81
            any(not isinstance(o, expected_type) for o in self.write_record),
 
82
            "Not all writes of type %s: %r" % (
 
83
                expected_type.__name__, self.write_record))
 
84
 
 
85
 
 
86
class TestDiffOptions(tests.TestCase):
 
87
 
 
88
    def test_unified_added(self):
 
89
        """Check for default style '-u' only if no other style specified
 
90
        in 'diff-options'.
 
91
        """
 
92
        # Verify that style defaults to unified, id est '-u' appended
 
93
        # to option list, in the absence of an alternative style.
 
94
        self.assertEqual(['-a', '-u'], diff.default_style_unified(['-a']))
 
95
 
 
96
 
 
97
class TestDiffOptionsScenarios(tests.TestCase):
 
98
 
 
99
    scenarios = [(s, dict(style=s)) for s in diff.style_option_list]
 
100
    style = None # Set by load_tests_apply_scenarios from scenarios
 
101
 
 
102
    def test_unified_not_added(self):
 
103
        # Verify that for all valid style options, '-u' is not
 
104
        # appended to option list.
 
105
        ret_opts = diff.default_style_unified(diff_opts=["%s" % (self.style,)])
 
106
        self.assertEqual(["%s" % (self.style,)], ret_opts)
 
107
 
 
108
 
83
109
class TestDiff(tests.TestCase):
84
110
 
85
111
    def test_add_nl(self):
86
112
        """diff generates a valid diff for patches that add a newline"""
87
113
        lines = udiff_lines(['boo'], ['boo\n'])
88
114
        self.check_patch(lines)
89
 
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
 
115
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
90
116
            ## "expected no-nl, got %r" % lines[4]
91
117
 
92
118
    def test_add_nl_2(self):
95
121
        """
96
122
        lines = udiff_lines(['boo'], ['goo\n'])
97
123
        self.check_patch(lines)
98
 
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
 
124
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
99
125
            ## "expected no-nl, got %r" % lines[4]
100
126
 
101
127
    def test_remove_nl(self):
104
130
        """
105
131
        lines = udiff_lines(['boo\n'], ['boo'])
106
132
        self.check_patch(lines)
107
 
        self.assertEquals(lines[5], '\\ No newline at end of file\n')
 
133
        self.assertEqual(lines[5], '\\ No newline at end of file\n')
108
134
            ## "expected no-nl, got %r" % lines[5]
109
135
 
110
136
    def check_patch(self, lines):
111
 
        self.assert_(len(lines) > 1)
 
137
        self.assertTrue(len(lines) > 1)
112
138
            ## "Not enough lines for a file header for patch:\n%s" % "".join(lines)
113
 
        self.assert_(lines[0].startswith ('---'))
 
139
        self.assertTrue(lines[0].startswith ('---'))
114
140
            ## 'No orig line for patch:\n%s' % "".join(lines)
115
 
        self.assert_(lines[1].startswith ('+++'))
 
141
        self.assertTrue(lines[1].startswith ('+++'))
116
142
            ## 'No mod line for patch:\n%s' % "".join(lines)
117
 
        self.assert_(len(lines) > 2)
 
143
        self.assertTrue(len(lines) > 2)
118
144
            ## "No hunks for patch:\n%s" % "".join(lines)
119
 
        self.assert_(lines[2].startswith('@@'))
 
145
        self.assertTrue(lines[2].startswith('@@'))
120
146
            ## "No hunk header for patch:\n%s" % "".join(lines)
121
 
        self.assert_('@@' in lines[2][2:])
 
147
        self.assertTrue('@@' in lines[2][2:])
122
148
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
123
149
 
124
150
    def test_binary_lines(self):
143
169
        self.check_patch(lines)
144
170
 
145
171
    def test_external_diff_binary_lang_c(self):
146
 
        old_env = {}
147
172
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
148
 
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
149
 
        try:
150
 
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
151
 
            # Older versions of diffutils say "Binary files", newer
152
 
            # versions just say "Files".
153
 
            self.assertContainsRe(lines[0],
154
 
                                  '(Binary f|F)iles old and new differ\n')
155
 
            self.assertEquals(lines[1:], ['\n'])
156
 
        finally:
157
 
            for lang, old_val in old_env.iteritems():
158
 
                osutils.set_or_unset_env(lang, old_val)
 
173
            self.overrideEnv(lang, 'C')
 
174
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
175
        # Older versions of diffutils say "Binary files", newer
 
176
        # versions just say "Files".
 
177
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
 
178
        self.assertEqual(lines[1:], ['\n'])
159
179
 
160
180
    def test_no_external_diff(self):
161
181
        """Check that NoDiff is raised when diff is not available"""
162
 
        # Use os.environ['PATH'] to make sure no 'diff' command is available
163
 
        orig_path = os.environ['PATH']
164
 
        try:
165
 
            os.environ['PATH'] = ''
166
 
            self.assertRaises(errors.NoDiff, diff.external_diff,
167
 
                              'old', ['boo\n'], 'new', ['goo\n'],
168
 
                              StringIO(), diff_opts=['-u'])
169
 
        finally:
170
 
            os.environ['PATH'] = orig_path
 
182
        # Make sure no 'diff' command is available
 
183
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
 
184
        self.overrideEnv('PATH', '')
 
185
        self.assertRaises(errors.NoDiff, diff.external_diff,
 
186
                          'old', ['boo\n'], 'new', ['goo\n'],
 
187
                          BytesIO(), diff_opts=['-u'])
171
188
 
172
189
    def test_internal_diff_default(self):
173
190
        # Default internal diff encoding is utf8
174
 
        output = StringIO()
 
191
        output = BytesIO()
175
192
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
176
193
                           u'new_\xe5', ['new_text\n'], output)
177
194
        lines = output.getvalue().splitlines(True)
178
195
        self.check_patch(lines)
179
 
        self.assertEquals(['--- old_\xc2\xb5\n',
 
196
        self.assertEqual(['--- old_\xc2\xb5\n',
180
197
                           '+++ new_\xc3\xa5\n',
181
198
                           '@@ -1,1 +1,1 @@\n',
182
199
                           '-old_text\n',
186
203
                          , lines)
187
204
 
188
205
    def test_internal_diff_utf8(self):
189
 
        output = StringIO()
 
206
        output = BytesIO()
190
207
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
191
208
                           u'new_\xe5', ['new_text\n'], output,
192
209
                           path_encoding='utf8')
193
210
        lines = output.getvalue().splitlines(True)
194
211
        self.check_patch(lines)
195
 
        self.assertEquals(['--- old_\xc2\xb5\n',
 
212
        self.assertEqual(['--- old_\xc2\xb5\n',
196
213
                           '+++ new_\xc3\xa5\n',
197
214
                           '@@ -1,1 +1,1 @@\n',
198
215
                           '-old_text\n',
202
219
                          , lines)
203
220
 
204
221
    def test_internal_diff_iso_8859_1(self):
205
 
        output = StringIO()
 
222
        output = BytesIO()
206
223
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
207
224
                           u'new_\xe5', ['new_text\n'], output,
208
225
                           path_encoding='iso-8859-1')
209
226
        lines = output.getvalue().splitlines(True)
210
227
        self.check_patch(lines)
211
 
        self.assertEquals(['--- old_\xb5\n',
 
228
        self.assertEqual(['--- old_\xb5\n',
212
229
                           '+++ new_\xe5\n',
213
230
                           '@@ -1,1 +1,1 @@\n',
214
231
                           '-old_text\n',
218
235
                          , lines)
219
236
 
220
237
    def test_internal_diff_no_content(self):
221
 
        output = StringIO()
 
238
        output = BytesIO()
222
239
        diff.internal_diff(u'old', [], u'new', [], output)
223
240
        self.assertEqual('', output.getvalue())
224
241
 
225
242
    def test_internal_diff_no_changes(self):
226
 
        output = StringIO()
 
243
        output = BytesIO()
227
244
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
228
245
                           u'new', ['text\n', 'contents\n'],
229
246
                           output)
230
247
        self.assertEqual('', output.getvalue())
231
248
 
232
249
    def test_internal_diff_returns_bytes(self):
233
 
        import StringIO
234
 
        output = StringIO.StringIO()
 
250
        output = StubO()
235
251
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
236
252
                            u'new_\xe5', ['new_text\n'], output)
237
 
        self.failUnless(isinstance(output.getvalue(), str),
238
 
            'internal_diff should return bytestrings')
 
253
        output.check_types(self, bytes)
 
254
 
 
255
    def test_internal_diff_default_context(self):
 
256
        output = BytesIO()
 
257
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
258
                           'same_text\n','same_text\n','old_text\n'],
 
259
                           'new', ['same_text\n','same_text\n','same_text\n',
 
260
                           'same_text\n','same_text\n','new_text\n'], output)
 
261
        lines = output.getvalue().splitlines(True)
 
262
        self.check_patch(lines)
 
263
        self.assertEqual(['--- old\n',
 
264
                           '+++ new\n',
 
265
                           '@@ -3,4 +3,4 @@\n',
 
266
                           ' same_text\n',
 
267
                           ' same_text\n',
 
268
                           ' same_text\n',
 
269
                           '-old_text\n',
 
270
                           '+new_text\n',
 
271
                           '\n',
 
272
                          ]
 
273
                          , lines)
 
274
 
 
275
    def test_internal_diff_no_context(self):
 
276
        output = BytesIO()
 
277
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
278
                           'same_text\n','same_text\n','old_text\n'],
 
279
                           'new', ['same_text\n','same_text\n','same_text\n',
 
280
                           'same_text\n','same_text\n','new_text\n'], output,
 
281
                           context_lines=0)
 
282
        lines = output.getvalue().splitlines(True)
 
283
        self.check_patch(lines)
 
284
        self.assertEqual(['--- old\n',
 
285
                           '+++ new\n',
 
286
                           '@@ -6,1 +6,1 @@\n',
 
287
                           '-old_text\n',
 
288
                           '+new_text\n',
 
289
                           '\n',
 
290
                          ]
 
291
                          , lines)
 
292
 
 
293
    def test_internal_diff_more_context(self):
 
294
        output = BytesIO()
 
295
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
296
                           'same_text\n','same_text\n','old_text\n'],
 
297
                           'new', ['same_text\n','same_text\n','same_text\n',
 
298
                           'same_text\n','same_text\n','new_text\n'], output,
 
299
                           context_lines=4)
 
300
        lines = output.getvalue().splitlines(True)
 
301
        self.check_patch(lines)
 
302
        self.assertEqual(['--- old\n',
 
303
                           '+++ new\n',
 
304
                           '@@ -2,5 +2,5 @@\n',
 
305
                           ' same_text\n',
 
306
                           ' same_text\n',
 
307
                           ' same_text\n',
 
308
                           ' same_text\n',
 
309
                           '-old_text\n',
 
310
                           '+new_text\n',
 
311
                           '\n',
 
312
                          ]
 
313
                          , lines)
 
314
 
 
315
 
 
316
 
239
317
 
240
318
 
241
319
class TestDiffFiles(tests.TestCaseInTempDir):
242
320
 
243
321
    def test_external_diff_binary(self):
244
322
        """The output when using external diff should use diff's i18n error"""
 
323
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
 
324
            self.overrideEnv(lang, 'C')
245
325
        # Make sure external_diff doesn't fail in the current LANG
246
326
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
247
327
 
248
328
        cmd = ['diff', '-u', '--binary', 'old', 'new']
249
 
        open('old', 'wb').write('\x00foobar\n')
250
 
        open('new', 'wb').write('foo\x00bar\n')
 
329
        with open('old', 'wb') as f: f.write('\x00foobar\n')
 
330
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
251
331
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
252
332
                                     stdin=subprocess.PIPE)
253
333
        out, err = pipe.communicate()
254
 
        # Diff returns '2' on Binary files.
255
 
        self.assertEqual(2, pipe.returncode)
256
334
        # We should output whatever diff tells us, plus a trailing newline
257
335
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
258
336
 
259
337
 
260
 
class TestShowDiffTreesHelper(tests.TestCaseWithTransport):
261
 
    """Has a helper for running show_diff_trees"""
262
 
 
263
 
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
264
 
        output = StringIO()
265
 
        if working_tree is not None:
266
 
            extra_trees = (working_tree,)
267
 
        else:
268
 
            extra_trees = ()
269
 
        diff.show_diff_trees(tree1, tree2, output,
270
 
                             specific_files=specific_files,
271
 
                             extra_trees=extra_trees, old_label='old/',
272
 
                             new_label='new/')
273
 
        return output.getvalue()
274
 
 
275
 
 
276
 
class TestDiffDates(TestShowDiffTreesHelper):
 
338
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
 
339
    output = BytesIO()
 
340
    if working_tree is not None:
 
341
        extra_trees = (working_tree,)
 
342
    else:
 
343
        extra_trees = ()
 
344
    diff.show_diff_trees(tree1, tree2, output,
 
345
        specific_files=specific_files,
 
346
        extra_trees=extra_trees, old_label='old/',
 
347
        new_label='new/')
 
348
    return output.getvalue()
 
349
 
 
350
 
 
351
class TestDiffDates(tests.TestCaseWithTransport):
277
352
 
278
353
    def setUp(self):
279
354
        super(TestDiffDates, self).setUp()
314
389
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
315
390
 
316
391
    def test_diff_rev_tree_working_tree(self):
317
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
392
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
318
393
        # note that the date for old/file1 is from rev 2 rather than from
319
394
        # the basis revision (rev 4)
320
395
        self.assertEqualDiff(output, '''\
330
405
    def test_diff_rev_tree_rev_tree(self):
331
406
        tree1 = self.b.repository.revision_tree('rev-2')
332
407
        tree2 = self.b.repository.revision_tree('rev-3')
333
 
        output = self.get_diff(tree1, tree2)
 
408
        output = get_diff_as_string(tree1, tree2)
334
409
        self.assertEqualDiff(output, '''\
335
410
=== modified file 'file2'
336
411
--- old/file2\t2006-04-01 00:00:00 +0000
344
419
    def test_diff_add_files(self):
345
420
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
346
421
        tree2 = self.b.repository.revision_tree('rev-1')
347
 
        output = self.get_diff(tree1, tree2)
 
422
        output = get_diff_as_string(tree1, tree2)
348
423
        # the files have the epoch time stamp for the tree in which
349
424
        # they don't exist.
350
425
        self.assertEqualDiff(output, '''\
365
440
    def test_diff_remove_files(self):
366
441
        tree1 = self.b.repository.revision_tree('rev-3')
367
442
        tree2 = self.b.repository.revision_tree('rev-4')
368
 
        output = self.get_diff(tree1, tree2)
 
443
        output = get_diff_as_string(tree1, tree2)
369
444
        # the file has the epoch time stamp for the tree in which
370
445
        # it doesn't exist.
371
446
        self.assertEqualDiff(output, '''\
382
457
        self.wt.rename_one('file1', 'file1b')
383
458
        old_tree = self.b.repository.revision_tree('rev-1')
384
459
        new_tree = self.b.repository.revision_tree('rev-4')
385
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
 
460
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
386
461
                            working_tree=self.wt)
387
462
        self.assertContainsRe(out, 'file1\t')
388
463
 
394
469
        self.wt.rename_one('file1', 'dir1/file1')
395
470
        old_tree = self.b.repository.revision_tree('rev-1')
396
471
        new_tree = self.b.repository.revision_tree('rev-4')
397
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
 
472
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
398
473
                            working_tree=self.wt)
399
474
        self.assertContainsRe(out, 'file1\t')
400
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
 
475
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
401
476
                            working_tree=self.wt)
402
477
        self.assertNotContainsRe(out, 'file1\t')
403
478
 
404
479
 
405
 
 
406
 
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
480
class TestShowDiffTrees(tests.TestCaseWithTransport):
407
481
    """Direct tests for show_diff_trees"""
408
482
 
409
483
    def test_modified_file(self):
414
488
        tree.commit('one', rev_id='rev-1')
415
489
 
416
490
        self.build_tree_contents([('tree/file', 'new contents\n')])
417
 
        d = self.get_diff(tree.basis_tree(), tree)
 
491
        d = get_diff_as_string(tree.basis_tree(), tree)
418
492
        self.assertContainsRe(d, "=== modified file 'file'\n")
419
493
        self.assertContainsRe(d, '--- old/file\t')
420
494
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
431
505
 
432
506
        tree.rename_one('dir', 'other')
433
507
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
434
 
        d = self.get_diff(tree.basis_tree(), tree)
 
508
        d = get_diff_as_string(tree.basis_tree(), tree)
435
509
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
436
510
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
437
511
        # XXX: This is technically incorrect, because it used to be at another
450
524
        tree.commit('one', rev_id='rev-1')
451
525
 
452
526
        tree.rename_one('dir', 'newdir')
453
 
        d = self.get_diff(tree.basis_tree(), tree)
 
527
        d = get_diff_as_string(tree.basis_tree(), tree)
454
528
        # Renaming a directory should be a single "you renamed this dir" even
455
529
        # when there are files inside.
456
530
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
463
537
        tree.commit('one', rev_id='rev-1')
464
538
 
465
539
        tree.rename_one('file', 'newname')
466
 
        d = self.get_diff(tree.basis_tree(), tree)
 
540
        d = get_diff_as_string(tree.basis_tree(), tree)
467
541
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
468
542
        # We shouldn't have a --- or +++ line, because there is no content
469
543
        # change
478
552
 
479
553
        tree.rename_one('file', 'newname')
480
554
        self.build_tree_contents([('tree/newname', 'new contents\n')])
481
 
        d = self.get_diff(tree.basis_tree(), tree)
 
555
        d = get_diff_as_string(tree.basis_tree(), tree)
482
556
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
483
557
        self.assertContainsRe(d, '--- old/file\t')
484
558
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
508
582
        tree.rename_one('c', 'new-c')
509
583
        tree.rename_one('d', 'new-d')
510
584
 
511
 
        d = self.get_diff(tree.basis_tree(), tree)
 
585
        d = get_diff_as_string(tree.basis_tree(), tree)
512
586
 
513
587
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
514
 
                                  ".*\+x to -x.*\)")
 
588
                                 r".*\+x to -x.*\)")
515
589
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
516
 
                                  ".*-x to \+x.*\)")
 
590
                                 r".*-x to \+x.*\)")
517
591
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
518
 
                                  ".*\+x to -x.*\)")
 
592
                                 r".*\+x to -x.*\)")
519
593
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
520
 
                                  ".*-x to \+x.*\)")
 
594
                                 r".*-x to \+x.*\)")
521
595
        self.assertNotContainsRe(d, r"file 'e'")
522
596
        self.assertNotContainsRe(d, r"file 'f'")
523
597
 
524
 
 
525
598
    def test_binary_unicode_filenames(self):
526
599
        """Test that contents of files are *not* encoded in UTF-8 when there
527
600
        is a binary file in the diff.
528
601
        """
529
602
        # See https://bugs.launchpad.net/bugs/110092.
530
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
603
        self.requireFeature(features.UnicodeFilenameFeature)
531
604
 
532
 
        # This bug isn't triggered with cStringIO.
533
 
        from StringIO import StringIO
534
605
        tree = self.make_branch_and_tree('tree')
535
606
        alpha, omega = u'\u03b1', u'\u03c9'
536
607
        alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')
540
611
              ('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])
541
612
        tree.add([alpha], ['file-id'])
542
613
        tree.add([omega], ['file-id-2'])
543
 
        diff_content = StringIO()
 
614
        diff_content = StubO()
544
615
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
545
 
        d = diff_content.getvalue()
 
616
        diff_content.check_types(self, bytes)
 
617
        d = b''.join(diff_content.write_record)
546
618
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
547
619
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
548
620
                              % (alpha_utf8, alpha_utf8))
552
624
 
553
625
    def test_unicode_filename(self):
554
626
        """Test when the filename are unicode."""
555
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
627
        self.requireFeature(features.UnicodeFilenameFeature)
556
628
 
557
629
        alpha, omega = u'\u03b1', u'\u03c9'
558
630
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
573
645
        tree.add(['add_'+alpha], ['file-id'])
574
646
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
575
647
 
576
 
        d = self.get_diff(tree.basis_tree(), tree)
 
648
        d = get_diff_as_string(tree.basis_tree(), tree)
577
649
        self.assertContainsRe(d,
578
650
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
579
651
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
580
652
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
581
653
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
582
654
 
 
655
    def test_unicode_filename_path_encoding(self):
 
656
        """Test for bug #382699: unicode filenames on Windows should be shown
 
657
        in user encoding.
 
658
        """
 
659
        self.requireFeature(features.UnicodeFilenameFeature)
 
660
        # The word 'test' in Russian
 
661
        _russian_test = u'\u0422\u0435\u0441\u0442'
 
662
        directory = _russian_test + u'/'
 
663
        test_txt = _russian_test + u'.txt'
 
664
        u1234 = u'\u1234.txt'
 
665
 
 
666
        tree = self.make_branch_and_tree('.')
 
667
        self.build_tree_contents([
 
668
            (test_txt, 'foo\n'),
 
669
            (u1234, 'foo\n'),
 
670
            (directory, None),
 
671
            ])
 
672
        tree.add([test_txt, u1234, directory])
 
673
 
 
674
        sio = BytesIO()
 
675
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
 
676
            path_encoding='cp1251')
 
677
 
 
678
        output = subst_dates(sio.getvalue())
 
679
        shouldbe = ('''\
 
680
=== added directory '%(directory)s'
 
681
=== added file '%(test_txt)s'
 
682
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
683
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
684
@@ -0,0 +1,1 @@
 
685
+foo
 
686
 
 
687
=== added file '?.txt'
 
688
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
689
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
690
@@ -0,0 +1,1 @@
 
691
+foo
 
692
 
 
693
''' % {'directory': _russian_test.encode('cp1251'),
 
694
       'test_txt': test_txt.encode('cp1251'),
 
695
      })
 
696
        self.assertEqualDiff(output, shouldbe)
 
697
 
583
698
 
584
699
class DiffWasIs(diff.DiffPath):
585
700
 
601
716
        self.new_tree = self.make_branch_and_tree('new-tree')
602
717
        self.new_tree.lock_write()
603
718
        self.addCleanup(self.new_tree.unlock)
604
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
719
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, BytesIO())
605
720
 
606
721
    def test_diff_text(self):
607
722
        self.build_tree_contents([('old-tree/olddir/',),
612
727
                                  ('new-tree/newdir/newfile', 'new\n')])
613
728
        self.new_tree.add('newdir')
614
729
        self.new_tree.add('newdir/newfile', 'file-id')
615
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
730
        differ = diff.DiffText(self.old_tree, self.new_tree, BytesIO())
616
731
        differ.diff_text('file-id', None, 'old label', 'new label')
617
732
        self.assertEqual(
618
733
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
644
759
        self.new_tree.add('file', 'file-id')
645
760
        os.unlink('old-tree/file')
646
761
        self.differ.show_diff(None)
647
 
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
 
762
        self.assertContainsRe(self.differ.to_file.getvalue(), r'\+contents')
648
763
 
649
764
    def test_diff_symlink(self):
650
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
765
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, BytesIO())
651
766
        differ.diff_symlink('old target', None)
652
767
        self.assertEqual("=== target was 'old target'\n",
653
768
                         differ.to_file.getvalue())
654
769
 
655
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
770
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, BytesIO())
656
771
        differ.diff_symlink(None, 'new target')
657
772
        self.assertEqual("=== target is 'new target'\n",
658
773
                         differ.to_file.getvalue())
659
774
 
660
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
775
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, BytesIO())
661
776
        differ.diff_symlink('old target', 'new target')
662
777
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
663
778
                         differ.to_file.getvalue())
675
790
        self.assertContainsRe(
676
791
            self.differ.to_file.getvalue(),
677
792
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
678
 
             ' \@\@\n-old\n\+new\n\n')
 
793
            r' \@\@\n-old\n\+new\n\n')
679
794
 
680
795
    def test_diff_kind_change(self):
681
 
        self.requireFeature(tests.SymlinkFeature)
 
796
        self.requireFeature(features.SymlinkFeature)
682
797
        self.build_tree_contents([('old-tree/olddir/',),
683
798
                                  ('old-tree/olddir/oldfile', 'old\n')])
684
799
        self.old_tree.add('olddir')
691
806
        self.assertContainsRe(
692
807
            self.differ.to_file.getvalue(),
693
808
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
694
 
             ' \@\@\n-old\n\n')
 
809
            r' \@\@\n-old\n\n')
695
810
        self.assertContainsRe(self.differ.to_file.getvalue(),
696
811
                              "=== target is u'new'\n")
697
812
 
717
832
        diff.DiffTree.diff_factories=old_diff_factories[:]
718
833
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
719
834
        try:
720
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
835
            differ = diff.DiffTree(self.old_tree, self.new_tree, BytesIO())
721
836
        finally:
722
837
            diff.DiffTree.diff_factories = old_diff_factories
723
838
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
724
839
        self.assertNotContainsRe(
725
840
            differ.to_file.getvalue(),
726
841
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
727
 
             ' \@\@\n-old\n\+new\n\n')
 
842
            r' \@\@\n-old\n\+new\n\n')
728
843
        self.assertContainsRe(differ.to_file.getvalue(),
729
844
                              'was: old\nis: new\n')
730
845
 
731
846
    def test_extra_factories(self):
732
847
        self.create_old_new()
733
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
 
848
        differ = diff.DiffTree(self.old_tree, self.new_tree, BytesIO(),
734
849
                               extra_factories=[DiffWasIs.from_diff_tree])
735
850
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
736
851
        self.assertNotContainsRe(
737
852
            differ.to_file.getvalue(),
738
853
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
739
 
             ' \@\@\n-old\n\+new\n\n')
 
854
            r' \@\@\n-old\n\+new\n\n')
740
855
        self.assertContainsRe(differ.to_file.getvalue(),
741
856
                              'was: old\nis: new\n')
742
857
 
764
879
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
765
880
        sm = self._PatienceSequenceMatcher(None, a, b)
766
881
        mb = sm.get_matching_blocks()
767
 
        self.assertEquals(35, len(mb))
 
882
        self.assertEqual(35, len(mb))
768
883
 
769
884
    def test_unique_lcs(self):
770
885
        unique_lcs = self._unique_lcs
771
 
        self.assertEquals(unique_lcs('', ''), [])
772
 
        self.assertEquals(unique_lcs('', 'a'), [])
773
 
        self.assertEquals(unique_lcs('a', ''), [])
774
 
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
775
 
        self.assertEquals(unique_lcs('a', 'b'), [])
776
 
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
777
 
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
778
 
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
779
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
886
        self.assertEqual(unique_lcs('', ''), [])
 
887
        self.assertEqual(unique_lcs('', 'a'), [])
 
888
        self.assertEqual(unique_lcs('a', ''), [])
 
889
        self.assertEqual(unique_lcs('a', 'a'), [(0,0)])
 
890
        self.assertEqual(unique_lcs('a', 'b'), [])
 
891
        self.assertEqual(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
 
892
        self.assertEqual(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
 
893
        self.assertEqual(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
 
894
        self.assertEqual(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
780
895
                                                         (3,3), (4,4)])
781
 
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
 
896
        self.assertEqual(unique_lcs('acbac', 'abc'), [(2,1)])
782
897
 
783
898
    def test_recurse_matches(self):
784
899
        def test_one(a, b, matches):
785
900
            test_matches = []
786
901
            self._recurse_matches(
787
902
                a, b, 0, 0, len(a), len(b), test_matches, 10)
788
 
            self.assertEquals(test_matches, matches)
 
903
            self.assertEqual(test_matches, matches)
789
904
 
790
905
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
791
906
                 [(0, 0), (2, 2), (4, 4)])
896
1011
    def test_opcodes(self):
897
1012
        def chk_ops(a, b, expected_codes):
898
1013
            s = self._PatienceSequenceMatcher(None, a, b)
899
 
            self.assertEquals(expected_codes, s.get_opcodes())
 
1014
            self.assertEqual(expected_codes, s.get_opcodes())
900
1015
 
901
1016
        chk_ops('', '', [])
902
1017
        chk_ops([], [], [])
972
1087
    def test_grouped_opcodes(self):
973
1088
        def chk_ops(a, b, expected_codes, n=3):
974
1089
            s = self._PatienceSequenceMatcher(None, a, b)
975
 
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
 
1090
            self.assertEqual(expected_codes, list(s.get_grouped_opcodes(n)))
976
1091
 
977
1092
        chk_ops('', '', [])
978
1093
        chk_ops([], [], [])
1072
1187
                 'how are you today?\n']
1073
1188
        unified_diff = patiencediff.unified_diff
1074
1189
        psm = self._PatienceSequenceMatcher
1075
 
        self.assertEquals(['--- \n',
 
1190
        self.assertEqual(['--- \n',
1076
1191
                           '+++ \n',
1077
1192
                           '@@ -1,3 +1,2 @@\n',
1078
1193
                           ' hello there\n',
1081
1196
                          ]
1082
1197
                          , list(unified_diff(txt_a, txt_b,
1083
1198
                                 sequencematcher=psm)))
1084
 
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1085
 
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
 
1199
        txt_a = [x+'\n' for x in 'abcdefghijklmnop']
 
1200
        txt_b = [x+'\n' for x in 'abcdefxydefghijklmnop']
1086
1201
        # This is the result with LongestCommonSubstring matching
1087
 
        self.assertEquals(['--- \n',
 
1202
        self.assertEqual(['--- \n',
1088
1203
                           '+++ \n',
1089
1204
                           '@@ -1,6 +1,11 @@\n',
1090
1205
                           ' a\n',
1100
1215
                           ' f\n']
1101
1216
                          , list(unified_diff(txt_a, txt_b)))
1102
1217
        # And the patience diff
1103
 
        self.assertEquals(['--- \n',
 
1218
        self.assertEqual(['--- \n',
1104
1219
                           '+++ \n',
1105
1220
                           '@@ -4,6 +4,11 @@\n',
1106
1221
                           ' d\n',
1126
1241
                 'how are you today?\n']
1127
1242
        unified_diff = patiencediff.unified_diff
1128
1243
        psm = self._PatienceSequenceMatcher
1129
 
        self.assertEquals(['--- a\t2008-08-08\n',
 
1244
        self.assertEqual(['--- a\t2008-08-08\n',
1130
1245
                           '+++ b\t2008-09-09\n',
1131
1246
                           '@@ -1,3 +1,2 @@\n',
1132
1247
                           ' hello there\n',
1142
1257
 
1143
1258
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1144
1259
 
1145
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1260
    _test_needs_features = [features.compiled_patiencediff_feature]
1146
1261
 
1147
1262
    def setUp(self):
1148
1263
        super(TestPatienceDiffLib_c, self).setUp()
1149
 
        from bzrlib import _patiencediff_c
 
1264
        from breezy import _patiencediff_c
1150
1265
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1151
1266
        self._recurse_matches = _patiencediff_c.recurse_matches_c
1152
1267
        self._PatienceSequenceMatcher = \
1179
1294
                 'how are you today?\n']
1180
1295
        txt_b = ['hello there\n',
1181
1296
                 'how are you today?\n']
1182
 
        open('a1', 'wb').writelines(txt_a)
1183
 
        open('b1', 'wb').writelines(txt_b)
 
1297
        with open('a1', 'wb') as f: f.writelines(txt_a)
 
1298
        with open('b1', 'wb') as f: f.writelines(txt_b)
1184
1299
 
1185
1300
        unified_diff_files = patiencediff.unified_diff_files
1186
1301
        psm = self._PatienceSequenceMatcher
1187
 
        self.assertEquals(['--- a1\n',
 
1302
        self.assertEqual(['--- a1\n',
1188
1303
                           '+++ b1\n',
1189
1304
                           '@@ -1,3 +1,2 @@\n',
1190
1305
                           ' hello there\n',
1194
1309
                          , list(unified_diff_files('a1', 'b1',
1195
1310
                                 sequencematcher=psm)))
1196
1311
 
1197
 
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1198
 
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1199
 
        open('a2', 'wb').writelines(txt_a)
1200
 
        open('b2', 'wb').writelines(txt_b)
 
1312
        txt_a = [x+'\n' for x in 'abcdefghijklmnop']
 
1313
        txt_b = [x+'\n' for x in 'abcdefxydefghijklmnop']
 
1314
        with open('a2', 'wb') as f: f.writelines(txt_a)
 
1315
        with open('b2', 'wb') as f: f.writelines(txt_b)
1201
1316
 
1202
1317
        # This is the result with LongestCommonSubstring matching
1203
 
        self.assertEquals(['--- a2\n',
 
1318
        self.assertEqual(['--- a2\n',
1204
1319
                           '+++ b2\n',
1205
1320
                           '@@ -1,6 +1,11 @@\n',
1206
1321
                           ' a\n',
1217
1332
                          , list(unified_diff_files('a2', 'b2')))
1218
1333
 
1219
1334
        # And the patience diff
1220
 
        self.assertEquals(['--- a2\n',
1221
 
                           '+++ b2\n',
1222
 
                           '@@ -4,6 +4,11 @@\n',
1223
 
                           ' d\n',
1224
 
                           ' e\n',
1225
 
                           ' f\n',
1226
 
                           '+x\n',
1227
 
                           '+y\n',
1228
 
                           '+d\n',
1229
 
                           '+e\n',
1230
 
                           '+f\n',
1231
 
                           ' g\n',
1232
 
                           ' h\n',
1233
 
                           ' i\n',
1234
 
                          ]
1235
 
                          , list(unified_diff_files('a2', 'b2',
1236
 
                                 sequencematcher=psm)))
 
1335
        self.assertEqual(['--- a2\n',
 
1336
                          '+++ b2\n',
 
1337
                          '@@ -4,6 +4,11 @@\n',
 
1338
                          ' d\n',
 
1339
                          ' e\n',
 
1340
                          ' f\n',
 
1341
                          '+x\n',
 
1342
                          '+y\n',
 
1343
                          '+d\n',
 
1344
                          '+e\n',
 
1345
                          '+f\n',
 
1346
                          ' g\n',
 
1347
                          ' h\n',
 
1348
                          ' i\n'],
 
1349
                         list(unified_diff_files('a2', 'b2',
 
1350
                                                 sequencematcher=psm)))
1237
1351
 
1238
1352
 
1239
1353
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1240
1354
 
1241
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1355
    _test_needs_features = [features.compiled_patiencediff_feature]
1242
1356
 
1243
1357
    def setUp(self):
1244
1358
        super(TestPatienceDiffLibFiles_c, self).setUp()
1245
 
        from bzrlib import _patiencediff_c
 
1359
        from breezy import _patiencediff_c
1246
1360
        self._PatienceSequenceMatcher = \
1247
1361
            _patiencediff_c.PatienceSequenceMatcher_c
1248
1362
 
1250
1364
class TestUsingCompiledIfAvailable(tests.TestCase):
1251
1365
 
1252
1366
    def test_PatienceSequenceMatcher(self):
1253
 
        if compiled_patiencediff_feature.available():
1254
 
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
 
1367
        if features.compiled_patiencediff_feature.available():
 
1368
            from breezy._patiencediff_c import PatienceSequenceMatcher_c
1255
1369
            self.assertIs(PatienceSequenceMatcher_c,
1256
1370
                          patiencediff.PatienceSequenceMatcher)
1257
1371
        else:
1258
 
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
 
1372
            from breezy._patiencediff_py import PatienceSequenceMatcher_py
1259
1373
            self.assertIs(PatienceSequenceMatcher_py,
1260
1374
                          patiencediff.PatienceSequenceMatcher)
1261
1375
 
1262
1376
    def test_unique_lcs(self):
1263
 
        if compiled_patiencediff_feature.available():
1264
 
            from bzrlib._patiencediff_c import unique_lcs_c
 
1377
        if features.compiled_patiencediff_feature.available():
 
1378
            from breezy._patiencediff_c import unique_lcs_c
1265
1379
            self.assertIs(unique_lcs_c,
1266
1380
                          patiencediff.unique_lcs)
1267
1381
        else:
1268
 
            from bzrlib._patiencediff_py import unique_lcs_py
 
1382
            from breezy._patiencediff_py import unique_lcs_py
1269
1383
            self.assertIs(unique_lcs_py,
1270
1384
                          patiencediff.unique_lcs)
1271
1385
 
1272
1386
    def test_recurse_matches(self):
1273
 
        if compiled_patiencediff_feature.available():
1274
 
            from bzrlib._patiencediff_c import recurse_matches_c
 
1387
        if features.compiled_patiencediff_feature.available():
 
1388
            from breezy._patiencediff_c import recurse_matches_c
1275
1389
            self.assertIs(recurse_matches_c,
1276
1390
                          patiencediff.recurse_matches)
1277
1391
        else:
1278
 
            from bzrlib._patiencediff_py import recurse_matches_py
 
1392
            from breezy._patiencediff_py import recurse_matches_py
1279
1393
            self.assertIs(recurse_matches_py,
1280
1394
                          patiencediff.recurse_matches)
1281
1395
 
1298
1412
                         diff_obj._get_command('old-path', 'new-path'))
1299
1413
 
1300
1414
    def test_from_string_path_with_backslashes(self):
1301
 
        self.requireFeature(test_win32utils.BackslashDirSeparatorFeature)
 
1415
        self.requireFeature(features.backslashdir_feature)
1302
1416
        tool = 'C:\\Tools\\Diff.exe'
1303
1417
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1304
1418
        self.addCleanup(diff_obj.finish)
1308
1422
                         diff_obj._get_command('old-path', 'new-path'))
1309
1423
 
1310
1424
    def test_execute(self):
1311
 
        output = StringIO()
 
1425
        output = BytesIO()
1312
1426
        diff_obj = diff.DiffFromTool(['python', '-c',
1313
1427
                                      'print "@old_path @new_path"'],
1314
1428
                                     None, None, output)
1316
1430
        diff_obj._execute('old', 'new')
1317
1431
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1318
1432
 
1319
 
    def test_excute_missing(self):
 
1433
    def test_execute_missing(self):
1320
1434
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1321
1435
                                     None, None, None)
1322
1436
        self.addCleanup(diff_obj.finish)
1326
1440
                         ' on this machine', str(e))
1327
1441
 
1328
1442
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1329
 
        self.requireFeature(AttribFeature)
1330
 
        output = StringIO()
 
1443
        self.requireFeature(features.AttribFeature)
 
1444
        output = BytesIO()
1331
1445
        tree = self.make_branch_and_tree('tree')
1332
1446
        self.build_tree_contents([('tree/file', 'content')])
1333
1447
        tree.add('file', 'file-id')
1356
1470
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1357
1471
 
1358
1472
    def test_prepare_files(self):
1359
 
        output = StringIO()
 
1473
        output = BytesIO()
1360
1474
        tree = self.make_branch_and_tree('tree')
1361
1475
        self.build_tree_contents([('tree/oldname', 'oldcontent')])
1362
1476
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1377
1491
                                      'print "@old_path @new_path"'],
1378
1492
                                     old_tree, tree, output)
1379
1493
        self.addCleanup(diff_obj.finish)
1380
 
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
 
1494
        self.assertContainsRe(diff_obj._root, 'brz-diff-[^/]*')
1381
1495
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1382
1496
                                                     'newname')
1383
1497
        self.assertContainsRe(old_path, 'old/oldname$')
1391
1505
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1392
1506
 
1393
1507
 
 
1508
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
 
1509
 
 
1510
    def test_encodable_filename(self):
 
1511
        # Just checks file path for external diff tool.
 
1512
        # We cannot change CPython's internal encoding used by os.exec*.
 
1513
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1514
                                    None, None, None)
 
1515
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1516
            encoding = scenario['encoding']
 
1517
            dirname = scenario['info']['directory']
 
1518
            filename = scenario['info']['filename']
 
1519
 
 
1520
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1521
            relpath = dirname + u'/' + filename
 
1522
            fullpath = diffobj._safe_filename('safe', relpath)
 
1523
            self.assertEqual(fullpath,
 
1524
                             fullpath.encode(encoding).decode(encoding))
 
1525
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
 
1526
 
 
1527
    def test_unencodable_filename(self):
 
1528
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1529
                                    None, None, None)
 
1530
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1531
            encoding = scenario['encoding']
 
1532
            dirname = scenario['info']['directory']
 
1533
            filename = scenario['info']['filename']
 
1534
 
 
1535
            if encoding == 'iso-8859-1':
 
1536
                encoding = 'iso-8859-2'
 
1537
            else:
 
1538
                encoding = 'iso-8859-1'
 
1539
 
 
1540
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1541
            relpath = dirname + u'/' + filename
 
1542
            fullpath = diffobj._safe_filename('safe', relpath)
 
1543
            self.assertEqual(fullpath,
 
1544
                             fullpath.encode(encoding).decode(encoding))
 
1545
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
 
1546
 
 
1547
 
1394
1548
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1395
1549
 
1396
1550
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1397
 
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
1398
 
        TestGetTreesAndBranchesToDiff.
1399
 
        """
 
1551
        """Call get_trees_and_branches_to_diff_locked."""
1400
1552
        return diff.get_trees_and_branches_to_diff_locked(
1401
1553
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1402
1554
 
1439
1591
        self.assertEqual(tree.branch.base, new_branch.base)
1440
1592
        self.assertIs(None, specific_files)
1441
1593
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
1442
 
 
1443
 
 
1444
 
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
1445
 
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
1446
 
    deprecated get_trees_and_branches_to_diff function.
1447
 
    """
1448
 
 
1449
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1450
 
        return self.applyDeprecated(
1451
 
            deprecated_in((2, 2, 0)), diff.get_trees_and_branches_to_diff,
1452
 
            path_list, revision_specs, old_url, new_url)
1453