/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 bzrlib/tests/test_diff.py

  • Committer: Martin von Gagern
  • Date: 2010-04-20 08:47:38 UTC
  • mfrom: (5167 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5195.
  • Revision ID: martin.vgagern@gmx.net-20100420084738-ygymnqmdllzrhpfn
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
18
18
import os.path
19
19
from cStringIO import StringIO
20
 
import errno
21
20
import subprocess
22
21
import sys
23
22
from tempfile import TemporaryFile
32
31
    external_diff,
33
32
    internal_diff,
34
33
    show_diff_trees,
 
34
    get_trees_and_branches_to_diff,
 
35
    get_trees_and_branches_to_diff_locked,
35
36
    )
36
37
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
37
38
import bzrlib.osutils as osutils
41
42
import bzrlib._patiencediff_py
42
43
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
43
44
                          TestCaseInTempDir, TestSkipped)
 
45
from bzrlib.revisiontree import RevisionTree
 
46
from bzrlib.revisionspec import RevisionSpec
 
47
from bzrlib.symbol_versioning import deprecated_in
 
48
 
 
49
from bzrlib.tests.test_win32utils import BackslashDirSeparatorFeature
44
50
 
45
51
 
46
52
class _AttribFeature(Feature):
60
66
AttribFeature = _AttribFeature()
61
67
 
62
68
 
63
 
class _CompiledPatienceDiffFeature(Feature):
64
 
 
65
 
    def _probe(self):
66
 
        try:
67
 
            import bzrlib._patiencediff_c
68
 
        except ImportError:
69
 
            return False
70
 
        return True
71
 
 
72
 
    def feature_name(self):
73
 
        return 'bzrlib._patiencediff_c'
74
 
 
75
 
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
 
69
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
 
70
                                    'bzrlib._patiencediff_c')
76
71
 
77
72
 
78
73
def udiff_lines(old, new, allow_binary=False):
184
179
                              StringIO(), diff_opts=['-u'])
185
180
        finally:
186
181
            os.environ['PATH'] = orig_path
187
 
        
 
182
 
188
183
    def test_internal_diff_default(self):
189
184
        # Default internal diff encoding is utf8
190
185
        output = StringIO()
355
350
+file2 contents at rev 3
356
351
 
357
352
''')
358
 
        
 
353
 
359
354
    def test_diff_add_files(self):
360
355
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
361
356
        tree2 = self.b.repository.revision_tree('rev-1')
397
392
        self.wt.rename_one('file1', 'file1b')
398
393
        old_tree = self.b.repository.revision_tree('rev-1')
399
394
        new_tree = self.b.repository.revision_tree('rev-4')
400
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
 
395
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
401
396
                            working_tree=self.wt)
402
397
        self.assertContainsRe(out, 'file1\t')
403
398
 
409
404
        self.wt.rename_one('file1', 'dir1/file1')
410
405
        old_tree = self.b.repository.revision_tree('rev-1')
411
406
        new_tree = self.b.repository.revision_tree('rev-4')
412
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
 
407
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
413
408
                            working_tree=self.wt)
414
409
        self.assertContainsRe(out, 'file1\t')
415
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
 
410
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
416
411
                            working_tree=self.wt)
417
412
        self.assertNotContainsRe(out, 'file1\t')
418
413
 
704
699
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
705
700
             ' \@\@\n-old\n\n')
706
701
        self.assertContainsRe(self.differ.to_file.getvalue(),
707
 
                              "=== target is 'new'\n")
 
702
                              "=== target is u'new'\n")
708
703
 
709
704
    def test_diff_directory(self):
710
705
        self.build_tree(['new-tree/new-dir/'])
787
782
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
788
783
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
789
784
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
790
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
 
785
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
791
786
                                                         (3,3), (4,4)])
792
787
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
793
788
 
808
803
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
809
804
                                          (4, 6), (5, 7), (6, 8)])
810
805
 
811
 
        # recurse_matches doesn't match non-unique 
 
806
        # recurse_matches doesn't match non-unique
812
807
        # lines surrounded by bogus text.
813
808
        # The update has been done in patiencediff.SequenceMatcher instead
814
809
 
951
946
                 ('delete', 1,2, 1,1),
952
947
                 ('equal',  2,3, 1,2),
953
948
                ])
954
 
        chk_ops('aBccDe', 'abccde', 
 
949
        chk_ops('aBccDe', 'abccde',
955
950
                [('equal',   0,1, 0,1),
956
951
                 ('replace', 1,5, 1,5),
957
952
                 ('equal',   5,6, 5,6),
958
953
                ])
959
 
        chk_ops('aBcDec', 'abcdec', 
 
954
        chk_ops('aBcDec', 'abcdec',
960
955
                [('equal',   0,1, 0,1),
961
956
                 ('replace', 1,2, 1,2),
962
957
                 ('equal',   2,3, 2,3),
963
958
                 ('replace', 3,4, 3,4),
964
959
                 ('equal',   4,6, 4,6),
965
960
                ])
966
 
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
 
961
        chk_ops('aBcdEcdFg', 'abcdecdfg',
967
962
                [('equal',   0,1, 0,1),
968
963
                 ('replace', 1,8, 1,8),
969
964
                 ('equal',   8,9, 8,9)
970
965
                ])
971
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
 
966
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
972
967
                [('equal',   0,1, 0,1),
973
968
                 ('replace', 1,2, 1,2),
974
969
                 ('equal',   2,4, 2,4),
1034
1029
    """
1035
1030
    gnxrf_netf = ['svyr*']
1036
1031
    gnxrf_bcgvbaf = ['ab-erphefr']
1037
 
  
 
1032
 
1038
1033
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1039
1034
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1040
1035
        vs vf_dhvrg():
1048
1043
'''.splitlines(True), '''\
1049
1044
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1050
1045
 
1051
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
 
1046
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
1052
1047
    nqq gurz.
1053
1048
    """
1054
1049
    gnxrf_netf = ['svyr*']
1083
1078
                 'how are you today?\n']
1084
1079
        unified_diff = bzrlib.patiencediff.unified_diff
1085
1080
        psm = self._PatienceSequenceMatcher
1086
 
        self.assertEquals([ '---  \n',
1087
 
                           '+++  \n',
 
1081
        self.assertEquals(['--- \n',
 
1082
                           '+++ \n',
1088
1083
                           '@@ -1,3 +1,2 @@\n',
1089
1084
                           ' hello there\n',
1090
1085
                           '-world\n',
1095
1090
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1096
1091
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1097
1092
        # This is the result with LongestCommonSubstring matching
1098
 
        self.assertEquals(['---  \n',
1099
 
                           '+++  \n',
 
1093
        self.assertEquals(['--- \n',
 
1094
                           '+++ \n',
1100
1095
                           '@@ -1,6 +1,11 @@\n',
1101
1096
                           ' a\n',
1102
1097
                           ' b\n',
1111
1106
                           ' f\n']
1112
1107
                          , list(unified_diff(txt_a, txt_b)))
1113
1108
        # And the patience diff
1114
 
        self.assertEquals(['---  \n',
1115
 
                           '+++  \n',
 
1109
        self.assertEquals(['--- \n',
 
1110
                           '+++ \n',
1116
1111
                           '@@ -4,6 +4,11 @@\n',
1117
1112
                           ' d\n',
1118
1113
                           ' e\n',
1129
1124
                          , list(unified_diff(txt_a, txt_b,
1130
1125
                                 sequencematcher=psm)))
1131
1126
 
 
1127
    def test_patience_unified_diff_with_dates(self):
 
1128
        txt_a = ['hello there\n',
 
1129
                 'world\n',
 
1130
                 'how are you today?\n']
 
1131
        txt_b = ['hello there\n',
 
1132
                 'how are you today?\n']
 
1133
        unified_diff = bzrlib.patiencediff.unified_diff
 
1134
        psm = self._PatienceSequenceMatcher
 
1135
        self.assertEquals(['--- a\t2008-08-08\n',
 
1136
                           '+++ b\t2008-09-09\n',
 
1137
                           '@@ -1,3 +1,2 @@\n',
 
1138
                           ' hello there\n',
 
1139
                           '-world\n',
 
1140
                           ' how are you today?\n'
 
1141
                          ]
 
1142
                          , list(unified_diff(txt_a, txt_b,
 
1143
                                 fromfile='a', tofile='b',
 
1144
                                 fromfiledate='2008-08-08',
 
1145
                                 tofiledate='2008-09-09',
 
1146
                                 sequencematcher=psm)))
 
1147
 
1132
1148
 
1133
1149
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1134
1150
 
1135
 
    _test_needs_features = [CompiledPatienceDiffFeature]
 
1151
    _test_needs_features = [compiled_patiencediff_feature]
1136
1152
 
1137
1153
    def setUp(self):
1138
1154
        super(TestPatienceDiffLib_c, self).setUp()
1174
1190
 
1175
1191
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1176
1192
        psm = self._PatienceSequenceMatcher
1177
 
        self.assertEquals(['--- a1 \n',
1178
 
                           '+++ b1 \n',
 
1193
        self.assertEquals(['--- a1\n',
 
1194
                           '+++ b1\n',
1179
1195
                           '@@ -1,3 +1,2 @@\n',
1180
1196
                           ' hello there\n',
1181
1197
                           '-world\n',
1190
1206
        open('b2', 'wb').writelines(txt_b)
1191
1207
 
1192
1208
        # This is the result with LongestCommonSubstring matching
1193
 
        self.assertEquals(['--- a2 \n',
1194
 
                           '+++ b2 \n',
 
1209
        self.assertEquals(['--- a2\n',
 
1210
                           '+++ b2\n',
1195
1211
                           '@@ -1,6 +1,11 @@\n',
1196
1212
                           ' a\n',
1197
1213
                           ' b\n',
1207
1223
                          , list(unified_diff_files('a2', 'b2')))
1208
1224
 
1209
1225
        # And the patience diff
1210
 
        self.assertEquals(['--- a2 \n',
1211
 
                           '+++ b2 \n',
 
1226
        self.assertEquals(['--- a2\n',
 
1227
                           '+++ b2\n',
1212
1228
                           '@@ -4,6 +4,11 @@\n',
1213
1229
                           ' d\n',
1214
1230
                           ' e\n',
1228
1244
 
1229
1245
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1230
1246
 
1231
 
    _test_needs_features = [CompiledPatienceDiffFeature]
 
1247
    _test_needs_features = [compiled_patiencediff_feature]
1232
1248
 
1233
1249
    def setUp(self):
1234
1250
        super(TestPatienceDiffLibFiles_c, self).setUp()
1240
1256
class TestUsingCompiledIfAvailable(TestCase):
1241
1257
 
1242
1258
    def test_PatienceSequenceMatcher(self):
1243
 
        if CompiledPatienceDiffFeature.available():
 
1259
        if compiled_patiencediff_feature.available():
1244
1260
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1245
1261
            self.assertIs(PatienceSequenceMatcher_c,
1246
1262
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1250
1266
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1251
1267
 
1252
1268
    def test_unique_lcs(self):
1253
 
        if CompiledPatienceDiffFeature.available():
 
1269
        if compiled_patiencediff_feature.available():
1254
1270
            from bzrlib._patiencediff_c import unique_lcs_c
1255
1271
            self.assertIs(unique_lcs_c,
1256
1272
                          bzrlib.patiencediff.unique_lcs)
1260
1276
                          bzrlib.patiencediff.unique_lcs)
1261
1277
 
1262
1278
    def test_recurse_matches(self):
1263
 
        if CompiledPatienceDiffFeature.available():
 
1279
        if compiled_patiencediff_feature.available():
1264
1280
            from bzrlib._patiencediff_c import recurse_matches_c
1265
1281
            self.assertIs(recurse_matches_c,
1266
1282
                          bzrlib.patiencediff.recurse_matches)
1275
1291
    def test_from_string(self):
1276
1292
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
1277
1293
        self.addCleanup(diff_obj.finish)
1278
 
        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],
 
1294
        self.assertEqual(['diff', '@old_path', '@new_path'],
1279
1295
            diff_obj.command_template)
1280
1296
 
1281
1297
    def test_from_string_u5(self):
1282
 
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
 
1298
        diff_obj = DiffFromTool.from_string('diff "-u 5"', None, None, None)
1283
1299
        self.addCleanup(diff_obj.finish)
1284
 
        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],
 
1300
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1285
1301
                         diff_obj.command_template)
1286
1302
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1287
1303
                         diff_obj._get_command('old-path', 'new-path'))
 
1304
        
 
1305
    def test_from_string_path_with_backslashes(self):
 
1306
        self.requireFeature(BackslashDirSeparatorFeature)
 
1307
        tool = 'C:\\Tools\\Diff.exe'
 
1308
        diff_obj = DiffFromTool.from_string(tool, None, None, None)
 
1309
        self.addCleanup(diff_obj.finish)
 
1310
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
 
1311
                         diff_obj.command_template)
 
1312
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
 
1313
                         diff_obj._get_command('old-path', 'new-path'))
1288
1314
 
1289
1315
    def test_execute(self):
1290
1316
        output = StringIO()
1291
1317
        diff_obj = DiffFromTool(['python', '-c',
1292
 
                                 'print "%(old_path)s %(new_path)s"'],
 
1318
                                 'print "@old_path @new_path"'],
1293
1319
                                None, None, output)
1294
1320
        self.addCleanup(diff_obj.finish)
1295
1321
        diff_obj._execute('old', 'new')
1313
1339
        tree.commit('old tree')
1314
1340
        tree.lock_read()
1315
1341
        self.addCleanup(tree.unlock)
 
1342
        basis_tree = tree.basis_tree()
 
1343
        basis_tree.lock_read()
 
1344
        self.addCleanup(basis_tree.unlock)
1316
1345
        diff_obj = DiffFromTool(['python', '-c',
1317
 
                                 'print "%(old_path)s %(new_path)s"'],
1318
 
                                tree, tree, output)
 
1346
                                 'print "@old_path @new_path"'],
 
1347
                                basis_tree, tree, output)
1319
1348
        diff_obj._prepare_files('file-id', 'file', 'file')
1320
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file', r'old\\file')
1321
 
        self.assertReadableByAttrib(diff_obj._root, 'new\\file', r'new\\file')
 
1349
        # The old content should be readonly
 
1350
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
 
1351
                                    r'R.*old\\file$')
 
1352
        # The new content should use the tree object, not a 'new' file anymore
 
1353
        self.assertEndsWith(tree.basedir, 'work/tree')
 
1354
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1322
1355
 
1323
1356
    def assertReadableByAttrib(self, cwd, relpath, regex):
1324
1357
        proc = subprocess.Popen(['attrib', relpath],
1325
1358
                                stdout=subprocess.PIPE,
1326
1359
                                cwd=cwd)
1327
 
        proc.wait()
1328
 
        result = proc.stdout.read()
1329
 
        self.assertContainsRe(result, regex)
 
1360
        (result, err) = proc.communicate()
 
1361
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1330
1362
 
1331
1363
    def test_prepare_files(self):
1332
1364
        output = StringIO()
1335
1367
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1336
1368
        tree.add('oldname', 'file-id')
1337
1369
        tree.add('oldname2', 'file2-id')
1338
 
        tree.commit('old tree', timestamp=0)
 
1370
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
 
1371
        tree.commit('old tree', timestamp=315532800)
1339
1372
        tree.rename_one('oldname', 'newname')
1340
1373
        tree.rename_one('oldname2', 'newname2')
1341
1374
        self.build_tree_contents([('tree/newname', 'newcontent')])
1346
1379
        tree.lock_read()
1347
1380
        self.addCleanup(tree.unlock)
1348
1381
        diff_obj = DiffFromTool(['python', '-c',
1349
 
                                 'print "%(old_path)s %(new_path)s"'],
 
1382
                                 'print "@old_path @new_path"'],
1350
1383
                                old_tree, tree, output)
1351
1384
        self.addCleanup(diff_obj.finish)
1352
1385
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1353
1386
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1354
1387
                                                     'newname')
1355
1388
        self.assertContainsRe(old_path, 'old/oldname$')
1356
 
        self.assertEqual(0, os.stat(old_path).st_mtime)
1357
 
        self.assertContainsRe(new_path, 'new/newname$')
 
1389
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
 
1390
        self.assertContainsRe(new_path, 'tree/newname$')
1358
1391
        self.assertFileEqual('oldcontent', old_path)
1359
1392
        self.assertFileEqual('newcontent', new_path)
1360
1393
        if osutils.host_os_dereferences_symlinks():
1361
1394
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1362
1395
        # make sure we can create files with the same parent directories
1363
1396
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
 
1397
 
 
1398
 
 
1399
class TestGetTreesAndBranchesToDiffLocked(TestCaseWithTransport):
 
1400
 
 
1401
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
 
1402
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
 
1403
        TestGetTreesAndBranchesToDiff.
 
1404
        """
 
1405
        return get_trees_and_branches_to_diff_locked(
 
1406
            path_list, revision_specs, old_url, new_url, self.addCleanup)
 
1407
 
 
1408
    def test_basic(self):
 
1409
        tree = self.make_branch_and_tree('tree')
 
1410
        (old_tree, new_tree,
 
1411
         old_branch, new_branch,
 
1412
         specific_files, extra_trees) = self.call_gtabtd(
 
1413
             ['tree'], None, None, None)
 
1414
 
 
1415
        self.assertIsInstance(old_tree, RevisionTree)
 
1416
        self.assertEqual(_mod_revision.NULL_REVISION, old_tree.get_revision_id())
 
1417
        self.assertEqual(tree.basedir, new_tree.basedir)
 
1418
        self.assertEqual(tree.branch.base, old_branch.base)
 
1419
        self.assertEqual(tree.branch.base, new_branch.base)
 
1420
        self.assertIs(None, specific_files)
 
1421
        self.assertIs(None, extra_trees)
 
1422
 
 
1423
    def test_with_rev_specs(self):
 
1424
        tree = self.make_branch_and_tree('tree')
 
1425
        self.build_tree_contents([('tree/file', 'oldcontent')])
 
1426
        tree.add('file', 'file-id')
 
1427
        tree.commit('old tree', timestamp=0, rev_id="old-id")
 
1428
        self.build_tree_contents([('tree/file', 'newcontent')])
 
1429
        tree.commit('new tree', timestamp=0, rev_id="new-id")
 
1430
 
 
1431
        revisions = [RevisionSpec.from_string('1'),
 
1432
                     RevisionSpec.from_string('2')]
 
1433
        (old_tree, new_tree,
 
1434
         old_branch, new_branch,
 
1435
         specific_files, extra_trees) = self.call_gtabtd(
 
1436
            ['tree'], revisions, None, None)
 
1437
 
 
1438
        self.assertIsInstance(old_tree, RevisionTree)
 
1439
        self.assertEqual("old-id", old_tree.get_revision_id())
 
1440
        self.assertIsInstance(new_tree, RevisionTree)
 
1441
        self.assertEqual("new-id", new_tree.get_revision_id())
 
1442
        self.assertEqual(tree.branch.base, old_branch.base)
 
1443
        self.assertEqual(tree.branch.base, new_branch.base)
 
1444
        self.assertIs(None, specific_files)
 
1445
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
 
1446
 
 
1447
 
 
1448
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
 
1449
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
 
1450
    deprecated get_trees_and_branches_to_diff function.
 
1451
    """
 
1452
 
 
1453
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
 
1454
        return self.applyDeprecated(
 
1455
            deprecated_in((2, 2, 0)), get_trees_and_branches_to_diff,
 
1456
            path_list, revision_specs, old_url, new_url)
 
1457