← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

(vila) Revise legal option names to be less drastic. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2014 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
17
17
import os
18
18
from cStringIO import StringIO
19
19
import subprocess
20
 
import sys
21
20
import tempfile
22
21
 
23
22
from bzrlib import (
32
31
    tests,
33
32
    transform,
34
33
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import features
 
34
from bzrlib.tests import (
 
35
    features,
 
36
    EncodingAdapter,
 
37
)
37
38
from bzrlib.tests.blackbox.test_diff import subst_dates
38
 
 
39
 
 
40
 
class _AttribFeature(tests.Feature):
41
 
 
42
 
    def _probe(self):
43
 
        if (sys.platform not in ('cygwin', 'win32')):
44
 
            return False
45
 
        try:
46
 
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
47
 
        except OSError, e:
48
 
            return False
49
 
        return (0 == proc.wait())
50
 
 
51
 
    def feature_name(self):
52
 
        return 'attrib Windows command-line tool'
53
 
 
54
 
AttribFeature = _AttribFeature()
55
 
 
56
 
 
57
 
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
58
 
                                    'bzrlib._patiencediff_c')
 
39
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
40
 
 
41
 
 
42
load_tests = load_tests_apply_scenarios
59
43
 
60
44
 
61
45
def udiff_lines(old, new, allow_binary=False):
81
65
    return lines
82
66
 
83
67
 
 
68
class TestDiffOptions(tests.TestCase):
 
69
 
 
70
    def test_unified_added(self):
 
71
        """Check for default style '-u' only if no other style specified
 
72
        in 'diff-options'.
 
73
        """
 
74
        # Verify that style defaults to unified, id est '-u' appended
 
75
        # to option list, in the absence of an alternative style.
 
76
        self.assertEqual(['-a', '-u'], diff.default_style_unified(['-a']))
 
77
 
 
78
 
 
79
class TestDiffOptionsScenarios(tests.TestCase):
 
80
 
 
81
    scenarios = [(s, dict(style=s)) for s in diff.style_option_list]
 
82
    style = None # Set by load_tests_apply_scenarios from scenarios
 
83
 
 
84
    def test_unified_not_added(self):
 
85
        # Verify that for all valid style options, '-u' is not
 
86
        # appended to option list.
 
87
        ret_opts = diff.default_style_unified(diff_opts=["%s" % (self.style,)])
 
88
        self.assertEqual(["%s" % (self.style,)], ret_opts)
 
89
 
 
90
 
84
91
class TestDiff(tests.TestCase):
85
92
 
86
93
    def test_add_nl(self):
226
233
        output = StringIO.StringIO()
227
234
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
228
235
                            u'new_\xe5', ['new_text\n'], output)
229
 
        self.failUnless(isinstance(output.getvalue(), str),
 
236
        self.assertIsInstance(output.getvalue(), str,
230
237
            'internal_diff should return bytestrings')
231
238
 
 
239
    def test_internal_diff_default_context(self):
 
240
        output = StringIO()
 
241
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
242
                           'same_text\n','same_text\n','old_text\n'],
 
243
                           'new', ['same_text\n','same_text\n','same_text\n',
 
244
                           'same_text\n','same_text\n','new_text\n'], output)
 
245
        lines = output.getvalue().splitlines(True)
 
246
        self.check_patch(lines)
 
247
        self.assertEquals(['--- old\n',
 
248
                           '+++ new\n',
 
249
                           '@@ -3,4 +3,4 @@\n',
 
250
                           ' same_text\n',
 
251
                           ' same_text\n',
 
252
                           ' same_text\n',
 
253
                           '-old_text\n',
 
254
                           '+new_text\n',
 
255
                           '\n',
 
256
                          ]
 
257
                          , lines)
 
258
 
 
259
    def test_internal_diff_no_context(self):
 
260
        output = StringIO()
 
261
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
262
                           'same_text\n','same_text\n','old_text\n'],
 
263
                           'new', ['same_text\n','same_text\n','same_text\n',
 
264
                           'same_text\n','same_text\n','new_text\n'], output,
 
265
                           context_lines=0)
 
266
        lines = output.getvalue().splitlines(True)
 
267
        self.check_patch(lines)
 
268
        self.assertEquals(['--- old\n',
 
269
                           '+++ new\n',
 
270
                           '@@ -6,1 +6,1 @@\n',
 
271
                           '-old_text\n',
 
272
                           '+new_text\n',
 
273
                           '\n',
 
274
                          ]
 
275
                          , lines)
 
276
 
 
277
    def test_internal_diff_more_context(self):
 
278
        output = StringIO()
 
279
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
280
                           'same_text\n','same_text\n','old_text\n'],
 
281
                           'new', ['same_text\n','same_text\n','same_text\n',
 
282
                           'same_text\n','same_text\n','new_text\n'], output,
 
283
                           context_lines=4)
 
284
        lines = output.getvalue().splitlines(True)
 
285
        self.check_patch(lines)
 
286
        self.assertEquals(['--- old\n',
 
287
                           '+++ new\n',
 
288
                           '@@ -2,5 +2,5 @@\n',
 
289
                           ' same_text\n',
 
290
                           ' same_text\n',
 
291
                           ' same_text\n',
 
292
                           ' same_text\n',
 
293
                           '-old_text\n',
 
294
                           '+new_text\n',
 
295
                           '\n',
 
296
                          ]
 
297
                          , lines)
 
298
 
 
299
 
 
300
 
 
301
 
232
302
 
233
303
class TestDiffFiles(tests.TestCaseInTempDir):
234
304
 
238
308
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
239
309
 
240
310
        cmd = ['diff', '-u', '--binary', 'old', 'new']
241
 
        open('old', 'wb').write('\x00foobar\n')
242
 
        open('new', 'wb').write('foo\x00bar\n')
 
311
        with open('old', 'wb') as f: f.write('\x00foobar\n')
 
312
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
243
313
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
244
314
                                     stdin=subprocess.PIPE)
245
315
        out, err = pipe.communicate()
249
319
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
250
320
 
251
321
 
252
 
class TestShowDiffTreesHelper(tests.TestCaseWithTransport):
253
 
    """Has a helper for running show_diff_trees"""
254
 
 
255
 
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
256
 
        output = StringIO()
257
 
        if working_tree is not None:
258
 
            extra_trees = (working_tree,)
259
 
        else:
260
 
            extra_trees = ()
261
 
        diff.show_diff_trees(tree1, tree2, output,
262
 
                             specific_files=specific_files,
263
 
                             extra_trees=extra_trees, old_label='old/',
264
 
                             new_label='new/')
265
 
        return output.getvalue()
266
 
 
267
 
 
268
 
class TestDiffDates(TestShowDiffTreesHelper):
 
322
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
 
323
    output = StringIO()
 
324
    if working_tree is not None:
 
325
        extra_trees = (working_tree,)
 
326
    else:
 
327
        extra_trees = ()
 
328
    diff.show_diff_trees(tree1, tree2, output,
 
329
        specific_files=specific_files,
 
330
        extra_trees=extra_trees, old_label='old/',
 
331
        new_label='new/')
 
332
    return output.getvalue()
 
333
 
 
334
 
 
335
class TestDiffDates(tests.TestCaseWithTransport):
269
336
 
270
337
    def setUp(self):
271
338
        super(TestDiffDates, self).setUp()
306
373
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
307
374
 
308
375
    def test_diff_rev_tree_working_tree(self):
309
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
376
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
310
377
        # note that the date for old/file1 is from rev 2 rather than from
311
378
        # the basis revision (rev 4)
312
379
        self.assertEqualDiff(output, '''\
322
389
    def test_diff_rev_tree_rev_tree(self):
323
390
        tree1 = self.b.repository.revision_tree('rev-2')
324
391
        tree2 = self.b.repository.revision_tree('rev-3')
325
 
        output = self.get_diff(tree1, tree2)
 
392
        output = get_diff_as_string(tree1, tree2)
326
393
        self.assertEqualDiff(output, '''\
327
394
=== modified file 'file2'
328
395
--- old/file2\t2006-04-01 00:00:00 +0000
336
403
    def test_diff_add_files(self):
337
404
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
338
405
        tree2 = self.b.repository.revision_tree('rev-1')
339
 
        output = self.get_diff(tree1, tree2)
 
406
        output = get_diff_as_string(tree1, tree2)
340
407
        # the files have the epoch time stamp for the tree in which
341
408
        # they don't exist.
342
409
        self.assertEqualDiff(output, '''\
357
424
    def test_diff_remove_files(self):
358
425
        tree1 = self.b.repository.revision_tree('rev-3')
359
426
        tree2 = self.b.repository.revision_tree('rev-4')
360
 
        output = self.get_diff(tree1, tree2)
 
427
        output = get_diff_as_string(tree1, tree2)
361
428
        # the file has the epoch time stamp for the tree in which
362
429
        # it doesn't exist.
363
430
        self.assertEqualDiff(output, '''\
374
441
        self.wt.rename_one('file1', 'file1b')
375
442
        old_tree = self.b.repository.revision_tree('rev-1')
376
443
        new_tree = self.b.repository.revision_tree('rev-4')
377
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
 
444
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
378
445
                            working_tree=self.wt)
379
446
        self.assertContainsRe(out, 'file1\t')
380
447
 
386
453
        self.wt.rename_one('file1', 'dir1/file1')
387
454
        old_tree = self.b.repository.revision_tree('rev-1')
388
455
        new_tree = self.b.repository.revision_tree('rev-4')
389
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
 
456
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
390
457
                            working_tree=self.wt)
391
458
        self.assertContainsRe(out, 'file1\t')
392
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
 
459
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
393
460
                            working_tree=self.wt)
394
461
        self.assertNotContainsRe(out, 'file1\t')
395
462
 
396
463
 
397
 
 
398
 
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
464
class TestShowDiffTrees(tests.TestCaseWithTransport):
399
465
    """Direct tests for show_diff_trees"""
400
466
 
401
467
    def test_modified_file(self):
406
472
        tree.commit('one', rev_id='rev-1')
407
473
 
408
474
        self.build_tree_contents([('tree/file', 'new contents\n')])
409
 
        d = self.get_diff(tree.basis_tree(), tree)
 
475
        d = get_diff_as_string(tree.basis_tree(), tree)
410
476
        self.assertContainsRe(d, "=== modified file 'file'\n")
411
477
        self.assertContainsRe(d, '--- old/file\t')
412
478
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
423
489
 
424
490
        tree.rename_one('dir', 'other')
425
491
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
426
 
        d = self.get_diff(tree.basis_tree(), tree)
 
492
        d = get_diff_as_string(tree.basis_tree(), tree)
427
493
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
428
494
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
429
495
        # XXX: This is technically incorrect, because it used to be at another
442
508
        tree.commit('one', rev_id='rev-1')
443
509
 
444
510
        tree.rename_one('dir', 'newdir')
445
 
        d = self.get_diff(tree.basis_tree(), tree)
 
511
        d = get_diff_as_string(tree.basis_tree(), tree)
446
512
        # Renaming a directory should be a single "you renamed this dir" even
447
513
        # when there are files inside.
448
514
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
455
521
        tree.commit('one', rev_id='rev-1')
456
522
 
457
523
        tree.rename_one('file', 'newname')
458
 
        d = self.get_diff(tree.basis_tree(), tree)
 
524
        d = get_diff_as_string(tree.basis_tree(), tree)
459
525
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
460
526
        # We shouldn't have a --- or +++ line, because there is no content
461
527
        # change
470
536
 
471
537
        tree.rename_one('file', 'newname')
472
538
        self.build_tree_contents([('tree/newname', 'new contents\n')])
473
 
        d = self.get_diff(tree.basis_tree(), tree)
 
539
        d = get_diff_as_string(tree.basis_tree(), tree)
474
540
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
475
541
        self.assertContainsRe(d, '--- old/file\t')
476
542
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
500
566
        tree.rename_one('c', 'new-c')
501
567
        tree.rename_one('d', 'new-d')
502
568
 
503
 
        d = self.get_diff(tree.basis_tree(), tree)
 
569
        d = get_diff_as_string(tree.basis_tree(), tree)
504
570
 
505
571
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
506
572
                                  ".*\+x to -x.*\)")
518
584
        is a binary file in the diff.
519
585
        """
520
586
        # See https://bugs.launchpad.net/bugs/110092.
521
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
587
        self.requireFeature(features.UnicodeFilenameFeature)
522
588
 
523
589
        # This bug isn't triggered with cStringIO.
524
590
        from StringIO import StringIO
543
609
 
544
610
    def test_unicode_filename(self):
545
611
        """Test when the filename are unicode."""
546
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
612
        self.requireFeature(features.UnicodeFilenameFeature)
547
613
 
548
614
        alpha, omega = u'\u03b1', u'\u03c9'
549
615
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
564
630
        tree.add(['add_'+alpha], ['file-id'])
565
631
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
566
632
 
567
 
        d = self.get_diff(tree.basis_tree(), tree)
 
633
        d = get_diff_as_string(tree.basis_tree(), tree)
568
634
        self.assertContainsRe(d,
569
635
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
570
636
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
575
641
        """Test for bug #382699: unicode filenames on Windows should be shown
576
642
        in user encoding.
577
643
        """
578
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
644
        self.requireFeature(features.UnicodeFilenameFeature)
579
645
        # The word 'test' in Russian
580
646
        _russian_test = u'\u0422\u0435\u0441\u0442'
581
647
        directory = _russian_test + u'/'
712
778
             ' \@\@\n-old\n\+new\n\n')
713
779
 
714
780
    def test_diff_kind_change(self):
715
 
        self.requireFeature(tests.SymlinkFeature)
 
781
        self.requireFeature(features.SymlinkFeature)
716
782
        self.build_tree_contents([('old-tree/olddir/',),
717
783
                                  ('old-tree/olddir/oldfile', 'old\n')])
718
784
        self.old_tree.add('olddir')
1176
1242
 
1177
1243
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1178
1244
 
1179
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1245
    _test_needs_features = [features.compiled_patiencediff_feature]
1180
1246
 
1181
1247
    def setUp(self):
1182
1248
        super(TestPatienceDiffLib_c, self).setUp()
1213
1279
                 'how are you today?\n']
1214
1280
        txt_b = ['hello there\n',
1215
1281
                 'how are you today?\n']
1216
 
        open('a1', 'wb').writelines(txt_a)
1217
 
        open('b1', 'wb').writelines(txt_b)
 
1282
        with open('a1', 'wb') as f: f.writelines(txt_a)
 
1283
        with open('b1', 'wb') as f: f.writelines(txt_b)
1218
1284
 
1219
1285
        unified_diff_files = patiencediff.unified_diff_files
1220
1286
        psm = self._PatienceSequenceMatcher
1230
1296
 
1231
1297
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1232
1298
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1233
 
        open('a2', 'wb').writelines(txt_a)
1234
 
        open('b2', 'wb').writelines(txt_b)
 
1299
        with open('a2', 'wb') as f: f.writelines(txt_a)
 
1300
        with open('b2', 'wb') as f: f.writelines(txt_b)
1235
1301
 
1236
1302
        # This is the result with LongestCommonSubstring matching
1237
1303
        self.assertEquals(['--- a2\n',
1272
1338
 
1273
1339
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1274
1340
 
1275
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1341
    _test_needs_features = [features.compiled_patiencediff_feature]
1276
1342
 
1277
1343
    def setUp(self):
1278
1344
        super(TestPatienceDiffLibFiles_c, self).setUp()
1284
1350
class TestUsingCompiledIfAvailable(tests.TestCase):
1285
1351
 
1286
1352
    def test_PatienceSequenceMatcher(self):
1287
 
        if compiled_patiencediff_feature.available():
 
1353
        if features.compiled_patiencediff_feature.available():
1288
1354
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1289
1355
            self.assertIs(PatienceSequenceMatcher_c,
1290
1356
                          patiencediff.PatienceSequenceMatcher)
1294
1360
                          patiencediff.PatienceSequenceMatcher)
1295
1361
 
1296
1362
    def test_unique_lcs(self):
1297
 
        if compiled_patiencediff_feature.available():
 
1363
        if features.compiled_patiencediff_feature.available():
1298
1364
            from bzrlib._patiencediff_c import unique_lcs_c
1299
1365
            self.assertIs(unique_lcs_c,
1300
1366
                          patiencediff.unique_lcs)
1304
1370
                          patiencediff.unique_lcs)
1305
1371
 
1306
1372
    def test_recurse_matches(self):
1307
 
        if compiled_patiencediff_feature.available():
 
1373
        if features.compiled_patiencediff_feature.available():
1308
1374
            from bzrlib._patiencediff_c import recurse_matches_c
1309
1375
            self.assertIs(recurse_matches_c,
1310
1376
                          patiencediff.recurse_matches)
1350
1416
        diff_obj._execute('old', 'new')
1351
1417
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1352
1418
 
1353
 
    def test_excute_missing(self):
 
1419
    def test_execute_missing(self):
1354
1420
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1355
1421
                                     None, None, None)
1356
1422
        self.addCleanup(diff_obj.finish)
1360
1426
                         ' on this machine', str(e))
1361
1427
 
1362
1428
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1363
 
        self.requireFeature(AttribFeature)
 
1429
        self.requireFeature(features.AttribFeature)
1364
1430
        output = StringIO()
1365
1431
        tree = self.make_branch_and_tree('tree')
1366
1432
        self.build_tree_contents([('tree/file', 'content')])
1425
1491
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1426
1492
 
1427
1493
 
 
1494
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
 
1495
 
 
1496
    def test_encodable_filename(self):
 
1497
        # Just checks file path for external diff tool.
 
1498
        # We cannot change CPython's internal encoding used by os.exec*.
 
1499
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1500
                                    None, None, None)
 
1501
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1502
            encoding = scenario['encoding']
 
1503
            dirname  = scenario['info']['directory']
 
1504
            filename = scenario['info']['filename']
 
1505
 
 
1506
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1507
            relpath = dirname + u'/' + filename
 
1508
            fullpath = diffobj._safe_filename('safe', relpath)
 
1509
            self.assertEqual(
 
1510
                    fullpath,
 
1511
                    fullpath.encode(encoding).decode(encoding)
 
1512
                    )
 
1513
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1514
 
 
1515
    def test_unencodable_filename(self):
 
1516
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1517
                                    None, None, None)
 
1518
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1519
            encoding = scenario['encoding']
 
1520
            dirname  = scenario['info']['directory']
 
1521
            filename = scenario['info']['filename']
 
1522
 
 
1523
            if encoding == 'iso-8859-1':
 
1524
                encoding = 'iso-8859-2'
 
1525
            else:
 
1526
                encoding = 'iso-8859-1'
 
1527
 
 
1528
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1529
            relpath = dirname + u'/' + filename
 
1530
            fullpath = diffobj._safe_filename('safe', relpath)
 
1531
            self.assertEqual(
 
1532
                    fullpath,
 
1533
                    fullpath.encode(encoding).decode(encoding)
 
1534
                    )
 
1535
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1536
 
 
1537
 
1428
1538
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1429
1539
 
1430
1540
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1431
 
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
1432
 
        TestGetTreesAndBranchesToDiff.
1433
 
        """
 
1541
        """Call get_trees_and_branches_to_diff_locked."""
1434
1542
        return diff.get_trees_and_branches_to_diff_locked(
1435
1543
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1436
1544
 
1473
1581
        self.assertEqual(tree.branch.base, new_branch.base)
1474
1582
        self.assertIs(None, specific_files)
1475
1583
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
1476
 
 
1477
 
 
1478
 
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
1479
 
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
1480
 
    deprecated get_trees_and_branches_to_diff function.
1481
 
    """
1482
 
 
1483
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1484
 
        return self.applyDeprecated(
1485
 
            deprecated_in((2, 2, 0)), diff.get_trees_and_branches_to_diff,
1486
 
            path_list, revision_specs, old_url, new_url)
1487