← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

  • Committer: John Arbash Meinel
  • Date: 2013-06-24 12:03:12 UTC
  • mfrom: (6437.77.2 2.5)
  • mto: This revision was merged to the branch mainline in revision 6579.
  • Revision ID: john@arbash-meinel.com-20130624120312-pmvck24x052csigx
Merge lp:bzr/2.5 r6515 to get the fix for bug #855155 (Dirstate.update_basis_by_delta)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
33
33
    transform,
34
34
    )
35
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')
 
36
from bzrlib.tests import features, EncodingAdapter
 
37
from bzrlib.tests.blackbox.test_diff import subst_dates
 
38
from bzrlib.tests import (
 
39
    features,
 
40
    )
58
41
 
59
42
 
60
43
def udiff_lines(old, new, allow_binary=False):
143
126
        self.check_patch(lines)
144
127
 
145
128
    def test_external_diff_binary_lang_c(self):
146
 
        old_env = {}
147
129
        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)
 
130
            self.overrideEnv(lang, 'C')
 
131
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
132
        # Older versions of diffutils say "Binary files", newer
 
133
        # versions just say "Files".
 
134
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
 
135
        self.assertEquals(lines[1:], ['\n'])
159
136
 
160
137
    def test_no_external_diff(self):
161
138
        """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
 
139
        # Make sure no 'diff' command is available
 
140
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
 
141
        self.overrideEnv('PATH', '')
 
142
        self.assertRaises(errors.NoDiff, diff.external_diff,
 
143
                          'old', ['boo\n'], 'new', ['goo\n'],
 
144
                          StringIO(), diff_opts=['-u'])
171
145
 
172
146
    def test_internal_diff_default(self):
173
147
        # Default internal diff encoding is utf8
234
208
        output = StringIO.StringIO()
235
209
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
236
210
                            u'new_\xe5', ['new_text\n'], output)
237
 
        self.failUnless(isinstance(output.getvalue(), str),
 
211
        self.assertIsInstance(output.getvalue(), str,
238
212
            'internal_diff should return bytestrings')
239
213
 
 
214
    def test_internal_diff_default_context(self):
 
215
        output = StringIO()
 
216
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
217
                           'same_text\n','same_text\n','old_text\n'],
 
218
                           'new', ['same_text\n','same_text\n','same_text\n',
 
219
                           'same_text\n','same_text\n','new_text\n'], output)
 
220
        lines = output.getvalue().splitlines(True)
 
221
        self.check_patch(lines)
 
222
        self.assertEquals(['--- old\n',
 
223
                           '+++ new\n',
 
224
                           '@@ -3,4 +3,4 @@\n',
 
225
                           ' same_text\n',
 
226
                           ' same_text\n',
 
227
                           ' same_text\n',
 
228
                           '-old_text\n',
 
229
                           '+new_text\n',
 
230
                           '\n',
 
231
                          ]
 
232
                          , lines)
 
233
 
 
234
    def test_internal_diff_no_context(self):
 
235
        output = StringIO()
 
236
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
237
                           'same_text\n','same_text\n','old_text\n'],
 
238
                           'new', ['same_text\n','same_text\n','same_text\n',
 
239
                           'same_text\n','same_text\n','new_text\n'], output,
 
240
                           context_lines=0)
 
241
        lines = output.getvalue().splitlines(True)
 
242
        self.check_patch(lines)
 
243
        self.assertEquals(['--- old\n',
 
244
                           '+++ new\n',
 
245
                           '@@ -6,1 +6,1 @@\n',
 
246
                           '-old_text\n',
 
247
                           '+new_text\n',
 
248
                           '\n',
 
249
                          ]
 
250
                          , lines)
 
251
 
 
252
    def test_internal_diff_more_context(self):
 
253
        output = StringIO()
 
254
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
255
                           'same_text\n','same_text\n','old_text\n'],
 
256
                           'new', ['same_text\n','same_text\n','same_text\n',
 
257
                           'same_text\n','same_text\n','new_text\n'], output,
 
258
                           context_lines=4)
 
259
        lines = output.getvalue().splitlines(True)
 
260
        self.check_patch(lines)
 
261
        self.assertEquals(['--- old\n',
 
262
                           '+++ new\n',
 
263
                           '@@ -2,5 +2,5 @@\n',
 
264
                           ' same_text\n',
 
265
                           ' same_text\n',
 
266
                           ' same_text\n',
 
267
                           ' same_text\n',
 
268
                           '-old_text\n',
 
269
                           '+new_text\n',
 
270
                           '\n',
 
271
                          ]
 
272
                          , lines)
 
273
 
 
274
 
 
275
 
 
276
 
240
277
 
241
278
class TestDiffFiles(tests.TestCaseInTempDir):
242
279
 
246
283
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
247
284
 
248
285
        cmd = ['diff', '-u', '--binary', 'old', 'new']
249
 
        open('old', 'wb').write('\x00foobar\n')
250
 
        open('new', 'wb').write('foo\x00bar\n')
 
286
        with open('old', 'wb') as f: f.write('\x00foobar\n')
 
287
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
251
288
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
252
289
                                     stdin=subprocess.PIPE)
253
290
        out, err = pipe.communicate()
257
294
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
258
295
 
259
296
 
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):
 
297
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
 
298
    output = StringIO()
 
299
    if working_tree is not None:
 
300
        extra_trees = (working_tree,)
 
301
    else:
 
302
        extra_trees = ()
 
303
    diff.show_diff_trees(tree1, tree2, output,
 
304
        specific_files=specific_files,
 
305
        extra_trees=extra_trees, old_label='old/',
 
306
        new_label='new/')
 
307
    return output.getvalue()
 
308
 
 
309
 
 
310
class TestDiffDates(tests.TestCaseWithTransport):
277
311
 
278
312
    def setUp(self):
279
313
        super(TestDiffDates, self).setUp()
314
348
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
315
349
 
316
350
    def test_diff_rev_tree_working_tree(self):
317
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
351
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
318
352
        # note that the date for old/file1 is from rev 2 rather than from
319
353
        # the basis revision (rev 4)
320
354
        self.assertEqualDiff(output, '''\
330
364
    def test_diff_rev_tree_rev_tree(self):
331
365
        tree1 = self.b.repository.revision_tree('rev-2')
332
366
        tree2 = self.b.repository.revision_tree('rev-3')
333
 
        output = self.get_diff(tree1, tree2)
 
367
        output = get_diff_as_string(tree1, tree2)
334
368
        self.assertEqualDiff(output, '''\
335
369
=== modified file 'file2'
336
370
--- old/file2\t2006-04-01 00:00:00 +0000
344
378
    def test_diff_add_files(self):
345
379
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
346
380
        tree2 = self.b.repository.revision_tree('rev-1')
347
 
        output = self.get_diff(tree1, tree2)
 
381
        output = get_diff_as_string(tree1, tree2)
348
382
        # the files have the epoch time stamp for the tree in which
349
383
        # they don't exist.
350
384
        self.assertEqualDiff(output, '''\
365
399
    def test_diff_remove_files(self):
366
400
        tree1 = self.b.repository.revision_tree('rev-3')
367
401
        tree2 = self.b.repository.revision_tree('rev-4')
368
 
        output = self.get_diff(tree1, tree2)
 
402
        output = get_diff_as_string(tree1, tree2)
369
403
        # the file has the epoch time stamp for the tree in which
370
404
        # it doesn't exist.
371
405
        self.assertEqualDiff(output, '''\
382
416
        self.wt.rename_one('file1', 'file1b')
383
417
        old_tree = self.b.repository.revision_tree('rev-1')
384
418
        new_tree = self.b.repository.revision_tree('rev-4')
385
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
 
419
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
386
420
                            working_tree=self.wt)
387
421
        self.assertContainsRe(out, 'file1\t')
388
422
 
394
428
        self.wt.rename_one('file1', 'dir1/file1')
395
429
        old_tree = self.b.repository.revision_tree('rev-1')
396
430
        new_tree = self.b.repository.revision_tree('rev-4')
397
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
 
431
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
398
432
                            working_tree=self.wt)
399
433
        self.assertContainsRe(out, 'file1\t')
400
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
 
434
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
401
435
                            working_tree=self.wt)
402
436
        self.assertNotContainsRe(out, 'file1\t')
403
437
 
404
438
 
405
 
 
406
 
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
439
class TestShowDiffTrees(tests.TestCaseWithTransport):
407
440
    """Direct tests for show_diff_trees"""
408
441
 
409
442
    def test_modified_file(self):
414
447
        tree.commit('one', rev_id='rev-1')
415
448
 
416
449
        self.build_tree_contents([('tree/file', 'new contents\n')])
417
 
        d = self.get_diff(tree.basis_tree(), tree)
 
450
        d = get_diff_as_string(tree.basis_tree(), tree)
418
451
        self.assertContainsRe(d, "=== modified file 'file'\n")
419
452
        self.assertContainsRe(d, '--- old/file\t')
420
453
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
431
464
 
432
465
        tree.rename_one('dir', 'other')
433
466
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
434
 
        d = self.get_diff(tree.basis_tree(), tree)
 
467
        d = get_diff_as_string(tree.basis_tree(), tree)
435
468
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
436
469
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
437
470
        # XXX: This is technically incorrect, because it used to be at another
450
483
        tree.commit('one', rev_id='rev-1')
451
484
 
452
485
        tree.rename_one('dir', 'newdir')
453
 
        d = self.get_diff(tree.basis_tree(), tree)
 
486
        d = get_diff_as_string(tree.basis_tree(), tree)
454
487
        # Renaming a directory should be a single "you renamed this dir" even
455
488
        # when there are files inside.
456
489
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
463
496
        tree.commit('one', rev_id='rev-1')
464
497
 
465
498
        tree.rename_one('file', 'newname')
466
 
        d = self.get_diff(tree.basis_tree(), tree)
 
499
        d = get_diff_as_string(tree.basis_tree(), tree)
467
500
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
468
501
        # We shouldn't have a --- or +++ line, because there is no content
469
502
        # change
478
511
 
479
512
        tree.rename_one('file', 'newname')
480
513
        self.build_tree_contents([('tree/newname', 'new contents\n')])
481
 
        d = self.get_diff(tree.basis_tree(), tree)
 
514
        d = get_diff_as_string(tree.basis_tree(), tree)
482
515
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
483
516
        self.assertContainsRe(d, '--- old/file\t')
484
517
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
508
541
        tree.rename_one('c', 'new-c')
509
542
        tree.rename_one('d', 'new-d')
510
543
 
511
 
        d = self.get_diff(tree.basis_tree(), tree)
 
544
        d = get_diff_as_string(tree.basis_tree(), tree)
512
545
 
513
546
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
514
547
                                  ".*\+x to -x.*\)")
521
554
        self.assertNotContainsRe(d, r"file 'e'")
522
555
        self.assertNotContainsRe(d, r"file 'f'")
523
556
 
524
 
 
525
557
    def test_binary_unicode_filenames(self):
526
558
        """Test that contents of files are *not* encoded in UTF-8 when there
527
559
        is a binary file in the diff.
528
560
        """
529
561
        # See https://bugs.launchpad.net/bugs/110092.
530
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
562
        self.requireFeature(features.UnicodeFilenameFeature)
531
563
 
532
564
        # This bug isn't triggered with cStringIO.
533
565
        from StringIO import StringIO
552
584
 
553
585
    def test_unicode_filename(self):
554
586
        """Test when the filename are unicode."""
555
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
587
        self.requireFeature(features.UnicodeFilenameFeature)
556
588
 
557
589
        alpha, omega = u'\u03b1', u'\u03c9'
558
590
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
573
605
        tree.add(['add_'+alpha], ['file-id'])
574
606
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
575
607
 
576
 
        d = self.get_diff(tree.basis_tree(), tree)
 
608
        d = get_diff_as_string(tree.basis_tree(), tree)
577
609
        self.assertContainsRe(d,
578
610
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
579
611
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
580
612
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
581
613
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
582
614
 
 
615
    def test_unicode_filename_path_encoding(self):
 
616
        """Test for bug #382699: unicode filenames on Windows should be shown
 
617
        in user encoding.
 
618
        """
 
619
        self.requireFeature(features.UnicodeFilenameFeature)
 
620
        # The word 'test' in Russian
 
621
        _russian_test = u'\u0422\u0435\u0441\u0442'
 
622
        directory = _russian_test + u'/'
 
623
        test_txt = _russian_test + u'.txt'
 
624
        u1234 = u'\u1234.txt'
 
625
 
 
626
        tree = self.make_branch_and_tree('.')
 
627
        self.build_tree_contents([
 
628
            (test_txt, 'foo\n'),
 
629
            (u1234, 'foo\n'),
 
630
            (directory, None),
 
631
            ])
 
632
        tree.add([test_txt, u1234, directory])
 
633
 
 
634
        sio = StringIO()
 
635
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
 
636
            path_encoding='cp1251')
 
637
 
 
638
        output = subst_dates(sio.getvalue())
 
639
        shouldbe = ('''\
 
640
=== added directory '%(directory)s'
 
641
=== added file '%(test_txt)s'
 
642
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
643
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
644
@@ -0,0 +1,1 @@
 
645
+foo
 
646
 
 
647
=== added file '?.txt'
 
648
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
649
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
650
@@ -0,0 +1,1 @@
 
651
+foo
 
652
 
 
653
''' % {'directory': _russian_test.encode('cp1251'),
 
654
       'test_txt': test_txt.encode('cp1251'),
 
655
      })
 
656
        self.assertEqualDiff(output, shouldbe)
 
657
 
583
658
 
584
659
class DiffWasIs(diff.DiffPath):
585
660
 
678
753
             ' \@\@\n-old\n\+new\n\n')
679
754
 
680
755
    def test_diff_kind_change(self):
681
 
        self.requireFeature(tests.SymlinkFeature)
 
756
        self.requireFeature(features.SymlinkFeature)
682
757
        self.build_tree_contents([('old-tree/olddir/',),
683
758
                                  ('old-tree/olddir/oldfile', 'old\n')])
684
759
        self.old_tree.add('olddir')
1142
1217
 
1143
1218
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1144
1219
 
1145
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1220
    _test_needs_features = [features.compiled_patiencediff_feature]
1146
1221
 
1147
1222
    def setUp(self):
1148
1223
        super(TestPatienceDiffLib_c, self).setUp()
1179
1254
                 'how are you today?\n']
1180
1255
        txt_b = ['hello there\n',
1181
1256
                 'how are you today?\n']
1182
 
        open('a1', 'wb').writelines(txt_a)
1183
 
        open('b1', 'wb').writelines(txt_b)
 
1257
        with open('a1', 'wb') as f: f.writelines(txt_a)
 
1258
        with open('b1', 'wb') as f: f.writelines(txt_b)
1184
1259
 
1185
1260
        unified_diff_files = patiencediff.unified_diff_files
1186
1261
        psm = self._PatienceSequenceMatcher
1196
1271
 
1197
1272
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1198
1273
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1199
 
        open('a2', 'wb').writelines(txt_a)
1200
 
        open('b2', 'wb').writelines(txt_b)
 
1274
        with open('a2', 'wb') as f: f.writelines(txt_a)
 
1275
        with open('b2', 'wb') as f: f.writelines(txt_b)
1201
1276
 
1202
1277
        # This is the result with LongestCommonSubstring matching
1203
1278
        self.assertEquals(['--- a2\n',
1238
1313
 
1239
1314
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1240
1315
 
1241
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1316
    _test_needs_features = [features.compiled_patiencediff_feature]
1242
1317
 
1243
1318
    def setUp(self):
1244
1319
        super(TestPatienceDiffLibFiles_c, self).setUp()
1250
1325
class TestUsingCompiledIfAvailable(tests.TestCase):
1251
1326
 
1252
1327
    def test_PatienceSequenceMatcher(self):
1253
 
        if compiled_patiencediff_feature.available():
 
1328
        if features.compiled_patiencediff_feature.available():
1254
1329
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1255
1330
            self.assertIs(PatienceSequenceMatcher_c,
1256
1331
                          patiencediff.PatienceSequenceMatcher)
1260
1335
                          patiencediff.PatienceSequenceMatcher)
1261
1336
 
1262
1337
    def test_unique_lcs(self):
1263
 
        if compiled_patiencediff_feature.available():
 
1338
        if features.compiled_patiencediff_feature.available():
1264
1339
            from bzrlib._patiencediff_c import unique_lcs_c
1265
1340
            self.assertIs(unique_lcs_c,
1266
1341
                          patiencediff.unique_lcs)
1270
1345
                          patiencediff.unique_lcs)
1271
1346
 
1272
1347
    def test_recurse_matches(self):
1273
 
        if compiled_patiencediff_feature.available():
 
1348
        if features.compiled_patiencediff_feature.available():
1274
1349
            from bzrlib._patiencediff_c import recurse_matches_c
1275
1350
            self.assertIs(recurse_matches_c,
1276
1351
                          patiencediff.recurse_matches)
1298
1373
                         diff_obj._get_command('old-path', 'new-path'))
1299
1374
 
1300
1375
    def test_from_string_path_with_backslashes(self):
1301
 
        self.requireFeature(test_win32utils.BackslashDirSeparatorFeature)
 
1376
        self.requireFeature(features.backslashdir_feature)
1302
1377
        tool = 'C:\\Tools\\Diff.exe'
1303
1378
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1304
1379
        self.addCleanup(diff_obj.finish)
1326
1401
                         ' on this machine', str(e))
1327
1402
 
1328
1403
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1329
 
        self.requireFeature(AttribFeature)
 
1404
        self.requireFeature(features.AttribFeature)
1330
1405
        output = StringIO()
1331
1406
        tree = self.make_branch_and_tree('tree')
1332
1407
        self.build_tree_contents([('tree/file', 'content')])
1391
1466
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1392
1467
 
1393
1468
 
 
1469
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
 
1470
 
 
1471
    def test_encodable_filename(self):
 
1472
        # Just checks file path for external diff tool.
 
1473
        # We cannot change CPython's internal encoding used by os.exec*.
 
1474
        import sys
 
1475
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1476
                                    None, None, None)
 
1477
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1478
            encoding = scenario['encoding']
 
1479
            dirname  = scenario['info']['directory']
 
1480
            filename = scenario['info']['filename']
 
1481
 
 
1482
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1483
            relpath = dirname + u'/' + filename
 
1484
            fullpath = diffobj._safe_filename('safe', relpath)
 
1485
            self.assertEqual(
 
1486
                    fullpath,
 
1487
                    fullpath.encode(encoding).decode(encoding)
 
1488
                    )
 
1489
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1490
 
 
1491
    def test_unencodable_filename(self):
 
1492
        import sys
 
1493
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1494
                                    None, None, None)
 
1495
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1496
            encoding = scenario['encoding']
 
1497
            dirname  = scenario['info']['directory']
 
1498
            filename = scenario['info']['filename']
 
1499
 
 
1500
            if encoding == 'iso-8859-1':
 
1501
                encoding = 'iso-8859-2'
 
1502
            else:
 
1503
                encoding = 'iso-8859-1'
 
1504
 
 
1505
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1506
            relpath = dirname + u'/' + filename
 
1507
            fullpath = diffobj._safe_filename('safe', relpath)
 
1508
            self.assertEqual(
 
1509
                    fullpath,
 
1510
                    fullpath.encode(encoding).decode(encoding)
 
1511
                    )
 
1512
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1513
 
 
1514
 
1394
1515
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1395
1516
 
1396
1517
    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
 
        """
 
1518
        """Call get_trees_and_branches_to_diff_locked."""
1400
1519
        return diff.get_trees_and_branches_to_diff_locked(
1401
1520
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1402
1521
 
1439
1558
        self.assertEqual(tree.branch.base, new_branch.base)
1440
1559
        self.assertIs(None, specific_files)
1441
1560
        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