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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
18
from cStringIO import StringIO
21
from tempfile import TemporaryFile
29
revision as _mod_revision,
23
from bzrlib.diff import (
35
from bzrlib.symbol_versioning import deprecated_in
36
from bzrlib.tests import test_win32utils
39
class _AttribFeature(tests.Feature):
32
from bzrlib.errors import BinaryFile, NoDiff
33
import bzrlib.osutils as osutils
34
import bzrlib.patiencediff
35
import bzrlib._patiencediff_py
36
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
37
TestCaseInTempDir, TestSkipped)
40
class _CompiledPatienceDiffFeature(Feature):
42
if (sys.platform not in ('cygwin', 'win32')):
45
proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
44
import bzrlib._patiencediff_c
48
return (0 == proc.wait())
50
49
def feature_name(self):
51
return 'attrib Windows command-line tool'
53
AttribFeature = _AttribFeature()
56
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
57
'bzrlib._patiencediff_c')
50
return 'bzrlib._patiencediff_c'
52
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
55
class _UnicodeFilename(Feature):
56
"""Does the filesystem support Unicode filenames?"""
61
except UnicodeEncodeError:
63
except (IOError, OSError):
64
# The filesystem allows the Unicode filename but the file doesn't
68
# The filesystem allows the Unicode filename and the file exists,
72
UnicodeFilename = _UnicodeFilename()
75
class TestUnicodeFilename(TestCase):
77
def test_probe_passes(self):
78
"""UnicodeFilename._probe passes."""
79
# We can't test much more than that because the behaviour depends
81
UnicodeFilename._probe()
60
84
def udiff_lines(old, new, allow_binary=False):
61
85
output = StringIO()
62
diff.internal_diff('old', old, 'new', new, output, allow_binary)
86
internal_diff('old', old, 'new', new, output, allow_binary)
64
88
return output.readlines()
479
500
tree.rename_one('file', 'newname')
480
501
self.build_tree_contents([('tree/newname', 'new contents\n')])
481
d = self.get_diff(tree.basis_tree(), tree)
482
self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
483
self.assertContainsRe(d, '--- old/file\t')
484
self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
485
self.assertContainsRe(d, '-contents\n'
489
def test_internal_diff_exec_property(self):
490
tree = self.make_branch_and_tree('tree')
492
tt = transform.TreeTransform(tree)
493
tt.new_file('a', tt.root, 'contents\n', 'a-id', True)
494
tt.new_file('b', tt.root, 'contents\n', 'b-id', False)
495
tt.new_file('c', tt.root, 'contents\n', 'c-id', True)
496
tt.new_file('d', tt.root, 'contents\n', 'd-id', False)
497
tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)
498
tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)
500
tree.commit('one', rev_id='rev-1')
502
tt = transform.TreeTransform(tree)
503
tt.set_executability(False, tt.trans_id_file_id('a-id'))
504
tt.set_executability(True, tt.trans_id_file_id('b-id'))
505
tt.set_executability(False, tt.trans_id_file_id('c-id'))
506
tt.set_executability(True, tt.trans_id_file_id('d-id'))
508
tree.rename_one('c', 'new-c')
509
tree.rename_one('d', 'new-d')
511
d = self.get_diff(tree.basis_tree(), tree)
513
self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
515
self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
517
self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
519
self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
521
self.assertNotContainsRe(d, r"file 'e'")
522
self.assertNotContainsRe(d, r"file 'f'")
502
diff = self.get_diff(tree.basis_tree(), tree)
503
self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
504
self.assertContainsRe(diff, '--- old/file\t')
505
self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
506
self.assertContainsRe(diff, '-contents\n'
525
509
def test_binary_unicode_filenames(self):
526
510
"""Test that contents of files are *not* encoded in UTF-8 when there
527
511
is a binary file in the diff.
529
513
# See https://bugs.launchpad.net/bugs/110092.
530
self.requireFeature(tests.UnicodeFilenameFeature)
514
self.requireFeature(UnicodeFilename)
532
516
# This bug isn't triggered with cStringIO.
533
517
from StringIO import StringIO
807
774
# This is what it currently gives:
808
775
test_one('aBccDe', 'abccde', [(0,0), (5,5)])
810
def assertDiffBlocks(self, a, b, expected_blocks):
811
"""Check that the sequence matcher returns the correct blocks.
813
:param a: A sequence to match
814
:param b: Another sequence to match
815
:param expected_blocks: The expected output, not including the final
816
matching block (len(a), len(b), 0)
818
matcher = self._PatienceSequenceMatcher(None, a, b)
819
blocks = matcher.get_matching_blocks()
821
self.assertEqual((len(a), len(b), 0), last)
822
self.assertEqual(expected_blocks, blocks)
824
777
def test_matching_blocks(self):
778
def chk_blocks(a, b, expected_blocks):
779
# difflib always adds a signature of the total
780
# length, with no matching entries at the end
781
s = self._PatienceSequenceMatcher(None, a, b)
782
blocks = s.get_matching_blocks()
783
self.assertEquals((len(a), len(b), 0), blocks[-1])
784
self.assertEquals(expected_blocks, blocks[:-1])
825
786
# Some basic matching tests
826
self.assertDiffBlocks('', '', [])
827
self.assertDiffBlocks([], [], [])
828
self.assertDiffBlocks('abc', '', [])
829
self.assertDiffBlocks('', 'abc', [])
830
self.assertDiffBlocks('abcd', 'abcd', [(0, 0, 4)])
831
self.assertDiffBlocks('abcd', 'abce', [(0, 0, 3)])
832
self.assertDiffBlocks('eabc', 'abce', [(1, 0, 3)])
833
self.assertDiffBlocks('eabce', 'abce', [(1, 0, 4)])
834
self.assertDiffBlocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
835
self.assertDiffBlocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
836
self.assertDiffBlocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
837
# This may check too much, but it checks to see that
787
chk_blocks('', '', [])
788
chk_blocks([], [], [])
789
chk_blocks('abc', '', [])
790
chk_blocks('', 'abc', [])
791
chk_blocks('abcd', 'abcd', [(0, 0, 4)])
792
chk_blocks('abcd', 'abce', [(0, 0, 3)])
793
chk_blocks('eabc', 'abce', [(1, 0, 3)])
794
chk_blocks('eabce', 'abce', [(1, 0, 4)])
795
chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
796
chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
797
chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
798
# This may check too much, but it checks to see that
838
799
# a copied block stays attached to the previous section,
839
800
# not the later one.
840
801
# difflib would tend to grab the trailing longest match
841
802
# which would make the diff not look right
842
self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
843
[(0, 0, 6), (6, 11, 10)])
803
chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
804
[(0, 0, 6), (6, 11, 10)])
845
806
# make sure it supports passing in lists
846
self.assertDiffBlocks(
847
808
['hello there\n',
849
810
'how are you today?\n'],
854
815
# non unique lines surrounded by non-matching lines
856
self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
817
chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
858
819
# But they only need to be locally unique
859
self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
820
chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
861
822
# non unique blocks won't be matched
862
self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
823
chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
864
825
# but locally unique ones will
865
self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
826
chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
866
827
(5,4,1), (7,5,2), (10,8,1)])
868
self.assertDiffBlocks('abbabbXd', 'cabbabxd', [(7,7,1)])
869
self.assertDiffBlocks('abbabbbb', 'cabbabbc', [])
870
self.assertDiffBlocks('bbbbbbbb', 'cbbbbbbc', [])
872
def test_matching_blocks_tuples(self):
873
# Some basic matching tests
874
self.assertDiffBlocks([], [], [])
875
self.assertDiffBlocks([('a',), ('b',), ('c,')], [], [])
876
self.assertDiffBlocks([], [('a',), ('b',), ('c,')], [])
877
self.assertDiffBlocks([('a',), ('b',), ('c,')],
878
[('a',), ('b',), ('c,')],
880
self.assertDiffBlocks([('a',), ('b',), ('c,')],
881
[('a',), ('b',), ('d,')],
883
self.assertDiffBlocks([('d',), ('b',), ('c,')],
884
[('a',), ('b',), ('c,')],
886
self.assertDiffBlocks([('d',), ('a',), ('b',), ('c,')],
887
[('a',), ('b',), ('c,')],
889
self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
890
[('a', 'b'), ('c', 'X'), ('e', 'f')],
891
[(0, 0, 1), (2, 2, 1)])
892
self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
893
[('a', 'b'), ('c', 'dX'), ('e', 'f')],
894
[(0, 0, 1), (2, 2, 1)])
829
chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
830
chk_blocks('abbabbbb', 'cabbabbc', [])
831
chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
896
833
def test_opcodes(self):
897
834
def chk_ops(a, b, expected_codes):
1009
946
def test_multiple_ranges(self):
1010
947
# There was an earlier bug where we used a bad set of ranges,
1011
948
# this triggers that specific bug, to make sure it doesn't regress
1012
self.assertDiffBlocks('abcdefghijklmnop',
1013
'abcXghiYZQRSTUVWXYZijklmnop',
1014
[(0, 0, 3), (6, 4, 3), (9, 20, 7)])
1016
self.assertDiffBlocks('ABCd efghIjk L',
1017
'AxyzBCn mo pqrstuvwI1 2 L',
1018
[(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
949
def chk_blocks(a, b, expected_blocks):
950
# difflib always adds a signature of the total
951
# length, with no matching entries at the end
952
s = self._PatienceSequenceMatcher(None, a, b)
953
blocks = s.get_matching_blocks()
955
self.assertEquals(x, (len(a), len(b), 0))
956
self.assertEquals(expected_blocks, blocks)
958
chk_blocks('abcdefghijklmnop'
959
, 'abcXghiYZQRSTUVWXYZijklmnop'
960
, [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
962
chk_blocks('ABCd efghIjk L'
963
, 'AxyzBCn mo pqrstuvwI1 2 L'
964
, [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
1020
966
# These are rot13 code snippets.
1021
self.assertDiffBlocks('''\
1022
968
trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1024
970
gnxrf_netf = ['svyr*']
1025
971
gnxrf_bcgvbaf = ['ab-erphefr']
1027
973
qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1028
974
sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1118
1064
, list(unified_diff(txt_a, txt_b,
1119
1065
sequencematcher=psm)))
1121
def test_patience_unified_diff_with_dates(self):
1122
txt_a = ['hello there\n',
1124
'how are you today?\n']
1125
txt_b = ['hello there\n',
1126
'how are you today?\n']
1127
unified_diff = patiencediff.unified_diff
1128
psm = self._PatienceSequenceMatcher
1129
self.assertEquals(['--- a\t2008-08-08\n',
1130
'+++ b\t2008-09-09\n',
1131
'@@ -1,3 +1,2 @@\n',
1134
' how are you today?\n'
1136
, list(unified_diff(txt_a, txt_b,
1137
fromfile='a', tofile='b',
1138
fromfiledate='2008-08-08',
1139
tofiledate='2008-09-09',
1140
sequencematcher=psm)))
1143
1068
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1145
_test_needs_features = [compiled_patiencediff_feature]
1070
_test_needs_features = [CompiledPatienceDiffFeature]
1147
1072
def setUp(self):
1148
1073
super(TestPatienceDiffLib_c, self).setUp()
1149
from bzrlib import _patiencediff_c
1150
self._unique_lcs = _patiencediff_c.unique_lcs_c
1151
self._recurse_matches = _patiencediff_c.recurse_matches_c
1074
import bzrlib._patiencediff_c
1075
self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
1076
self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
1152
1077
self._PatienceSequenceMatcher = \
1153
_patiencediff_c.PatienceSequenceMatcher_c
1155
def test_unhashable(self):
1156
"""We should get a proper exception here."""
1157
# We need to be able to hash items in the sequence, lists are
1158
# unhashable, and thus cannot be diffed
1159
e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1161
e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1162
None, ['valid', []], [])
1163
e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1164
None, ['valid'], [[]])
1165
e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1166
None, ['valid'], ['valid', []])
1169
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
1078
bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1081
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1171
1083
def setUp(self):
1172
1084
super(TestPatienceDiffLibFiles, self).setUp()
1173
1085
self._PatienceSequenceMatcher = \
1174
_patiencediff_py.PatienceSequenceMatcher_py
1086
bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1176
1088
def test_patience_unified_diff_files(self):
1177
1089
txt_a = ['hello there\n',
1239
1151
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1241
_test_needs_features = [compiled_patiencediff_feature]
1153
_test_needs_features = [CompiledPatienceDiffFeature]
1243
1155
def setUp(self):
1244
1156
super(TestPatienceDiffLibFiles_c, self).setUp()
1245
from bzrlib import _patiencediff_c
1157
import bzrlib._patiencediff_c
1246
1158
self._PatienceSequenceMatcher = \
1247
_patiencediff_c.PatienceSequenceMatcher_c
1250
class TestUsingCompiledIfAvailable(tests.TestCase):
1159
bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1162
class TestUsingCompiledIfAvailable(TestCase):
1252
1164
def test_PatienceSequenceMatcher(self):
1253
if compiled_patiencediff_feature.available():
1165
if CompiledPatienceDiffFeature.available():
1254
1166
from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1255
1167
self.assertIs(PatienceSequenceMatcher_c,
1256
patiencediff.PatienceSequenceMatcher)
1168
bzrlib.patiencediff.PatienceSequenceMatcher)
1258
1170
from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1259
1171
self.assertIs(PatienceSequenceMatcher_py,
1260
patiencediff.PatienceSequenceMatcher)
1172
bzrlib.patiencediff.PatienceSequenceMatcher)
1262
1174
def test_unique_lcs(self):
1263
if compiled_patiencediff_feature.available():
1175
if CompiledPatienceDiffFeature.available():
1264
1176
from bzrlib._patiencediff_c import unique_lcs_c
1265
1177
self.assertIs(unique_lcs_c,
1266
patiencediff.unique_lcs)
1178
bzrlib.patiencediff.unique_lcs)
1268
1180
from bzrlib._patiencediff_py import unique_lcs_py
1269
1181
self.assertIs(unique_lcs_py,
1270
patiencediff.unique_lcs)
1182
bzrlib.patiencediff.unique_lcs)
1272
1184
def test_recurse_matches(self):
1273
if compiled_patiencediff_feature.available():
1185
if CompiledPatienceDiffFeature.available():
1274
1186
from bzrlib._patiencediff_c import recurse_matches_c
1275
1187
self.assertIs(recurse_matches_c,
1276
patiencediff.recurse_matches)
1188
bzrlib.patiencediff.recurse_matches)
1278
1190
from bzrlib._patiencediff_py import recurse_matches_py
1279
1191
self.assertIs(recurse_matches_py,
1280
patiencediff.recurse_matches)
1283
class TestDiffFromTool(tests.TestCaseWithTransport):
1285
def test_from_string(self):
1286
diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
1287
self.addCleanup(diff_obj.finish)
1288
self.assertEqual(['diff', '@old_path', '@new_path'],
1289
diff_obj.command_template)
1291
def test_from_string_u5(self):
1292
diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1294
self.addCleanup(diff_obj.finish)
1295
self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1296
diff_obj.command_template)
1297
self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1298
diff_obj._get_command('old-path', 'new-path'))
1300
def test_from_string_path_with_backslashes(self):
1301
self.requireFeature(test_win32utils.BackslashDirSeparatorFeature)
1302
tool = 'C:\\Tools\\Diff.exe'
1303
diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1304
self.addCleanup(diff_obj.finish)
1305
self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1306
diff_obj.command_template)
1307
self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
1308
diff_obj._get_command('old-path', 'new-path'))
1310
def test_execute(self):
1312
diff_obj = diff.DiffFromTool(['python', '-c',
1313
'print "@old_path @new_path"'],
1315
self.addCleanup(diff_obj.finish)
1316
diff_obj._execute('old', 'new')
1317
self.assertEqual(output.getvalue().rstrip(), 'old new')
1319
def test_excute_missing(self):
1320
diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1322
self.addCleanup(diff_obj.finish)
1323
e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1325
self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1326
' on this machine', str(e))
1328
def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1329
self.requireFeature(AttribFeature)
1331
tree = self.make_branch_and_tree('tree')
1332
self.build_tree_contents([('tree/file', 'content')])
1333
tree.add('file', 'file-id')
1334
tree.commit('old tree')
1336
self.addCleanup(tree.unlock)
1337
basis_tree = tree.basis_tree()
1338
basis_tree.lock_read()
1339
self.addCleanup(basis_tree.unlock)
1340
diff_obj = diff.DiffFromTool(['python', '-c',
1341
'print "@old_path @new_path"'],
1342
basis_tree, tree, output)
1343
diff_obj._prepare_files('file-id', 'file', 'file')
1344
# The old content should be readonly
1345
self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1347
# The new content should use the tree object, not a 'new' file anymore
1348
self.assertEndsWith(tree.basedir, 'work/tree')
1349
self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1351
def assertReadableByAttrib(self, cwd, relpath, regex):
1352
proc = subprocess.Popen(['attrib', relpath],
1353
stdout=subprocess.PIPE,
1355
(result, err) = proc.communicate()
1356
self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1358
def test_prepare_files(self):
1360
tree = self.make_branch_and_tree('tree')
1361
self.build_tree_contents([('tree/oldname', 'oldcontent')])
1362
self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1363
tree.add('oldname', 'file-id')
1364
tree.add('oldname2', 'file2-id')
1365
# Earliest allowable date on FAT32 filesystems is 1980-01-01
1366
tree.commit('old tree', timestamp=315532800)
1367
tree.rename_one('oldname', 'newname')
1368
tree.rename_one('oldname2', 'newname2')
1369
self.build_tree_contents([('tree/newname', 'newcontent')])
1370
self.build_tree_contents([('tree/newname2', 'newcontent2')])
1371
old_tree = tree.basis_tree()
1372
old_tree.lock_read()
1373
self.addCleanup(old_tree.unlock)
1375
self.addCleanup(tree.unlock)
1376
diff_obj = diff.DiffFromTool(['python', '-c',
1377
'print "@old_path @new_path"'],
1378
old_tree, tree, output)
1379
self.addCleanup(diff_obj.finish)
1380
self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1381
old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1383
self.assertContainsRe(old_path, 'old/oldname$')
1384
self.assertEqual(315532800, os.stat(old_path).st_mtime)
1385
self.assertContainsRe(new_path, 'tree/newname$')
1386
self.assertFileEqual('oldcontent', old_path)
1387
self.assertFileEqual('newcontent', new_path)
1388
if osutils.host_os_dereferences_symlinks():
1389
self.assertTrue(os.path.samefile('tree/newname', new_path))
1390
# make sure we can create files with the same parent directories
1391
diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1394
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1396
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.
1400
return diff.get_trees_and_branches_to_diff_locked(
1401
path_list, revision_specs, old_url, new_url, self.addCleanup)
1403
def test_basic(self):
1404
tree = self.make_branch_and_tree('tree')
1405
(old_tree, new_tree,
1406
old_branch, new_branch,
1407
specific_files, extra_trees) = self.call_gtabtd(
1408
['tree'], None, None, None)
1410
self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1411
self.assertEqual(_mod_revision.NULL_REVISION,
1412
old_tree.get_revision_id())
1413
self.assertEqual(tree.basedir, new_tree.basedir)
1414
self.assertEqual(tree.branch.base, old_branch.base)
1415
self.assertEqual(tree.branch.base, new_branch.base)
1416
self.assertIs(None, specific_files)
1417
self.assertIs(None, extra_trees)
1419
def test_with_rev_specs(self):
1420
tree = self.make_branch_and_tree('tree')
1421
self.build_tree_contents([('tree/file', 'oldcontent')])
1422
tree.add('file', 'file-id')
1423
tree.commit('old tree', timestamp=0, rev_id="old-id")
1424
self.build_tree_contents([('tree/file', 'newcontent')])
1425
tree.commit('new tree', timestamp=0, rev_id="new-id")
1427
revisions = [revisionspec.RevisionSpec.from_string('1'),
1428
revisionspec.RevisionSpec.from_string('2')]
1429
(old_tree, new_tree,
1430
old_branch, new_branch,
1431
specific_files, extra_trees) = self.call_gtabtd(
1432
['tree'], revisions, None, None)
1434
self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1435
self.assertEqual("old-id", old_tree.get_revision_id())
1436
self.assertIsInstance(new_tree, revisiontree.RevisionTree)
1437
self.assertEqual("new-id", new_tree.get_revision_id())
1438
self.assertEqual(tree.branch.base, old_branch.base)
1439
self.assertEqual(tree.branch.base, new_branch.base)
1440
self.assertIs(None, specific_files)
1441
self.assertEqual(tree.basedir, extra_trees[0].basedir)
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.
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)
1192
bzrlib.patiencediff.recurse_matches)