← 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: Vincent Ladeuil
  • Date: 2010-03-09 15:33:25 UTC
  • mto: (5082.2.1 integration2)
  • mto: This revision was merged to the branch mainline in revision 5084.
  • Revision ID: v.ladeuil+lp@free.fr-20100309153325-w16djg6tbkt0905a
Deprecate Merge3Merger.scalar_three_way.

* bzrlib/merge.py:
(Merge3Merger.scalar_three_way): Deprecated, not used in the
current code base, skimming history seem to reveal it hasn't been
used for quite a long time.

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
32
32
    external_diff,
33
33
    internal_diff,
34
34
    show_diff_trees,
 
35
    get_trees_and_branches_to_diff,
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
 
 
48
from bzrlib.tests.test_win32utils import BackslashDirSeparatorFeature
44
49
 
45
50
 
46
51
class _AttribFeature(Feature):
60
65
AttribFeature = _AttribFeature()
61
66
 
62
67
 
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()
 
68
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
 
69
                                    'bzrlib._patiencediff_c')
76
70
 
77
71
 
78
72
def udiff_lines(old, new, allow_binary=False):
184
178
                              StringIO(), diff_opts=['-u'])
185
179
        finally:
186
180
            os.environ['PATH'] = orig_path
187
 
        
 
181
 
188
182
    def test_internal_diff_default(self):
189
183
        # Default internal diff encoding is utf8
190
184
        output = StringIO()
355
349
+file2 contents at rev 3
356
350
 
357
351
''')
358
 
        
 
352
 
359
353
    def test_diff_add_files(self):
360
354
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
361
355
        tree2 = self.b.repository.revision_tree('rev-1')
397
391
        self.wt.rename_one('file1', 'file1b')
398
392
        old_tree = self.b.repository.revision_tree('rev-1')
399
393
        new_tree = self.b.repository.revision_tree('rev-4')
400
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
 
394
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
401
395
                            working_tree=self.wt)
402
396
        self.assertContainsRe(out, 'file1\t')
403
397
 
409
403
        self.wt.rename_one('file1', 'dir1/file1')
410
404
        old_tree = self.b.repository.revision_tree('rev-1')
411
405
        new_tree = self.b.repository.revision_tree('rev-4')
412
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
 
406
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
413
407
                            working_tree=self.wt)
414
408
        self.assertContainsRe(out, 'file1\t')
415
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
 
409
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
416
410
                            working_tree=self.wt)
417
411
        self.assertNotContainsRe(out, 'file1\t')
418
412
 
704
698
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
705
699
             ' \@\@\n-old\n\n')
706
700
        self.assertContainsRe(self.differ.to_file.getvalue(),
707
 
                              "=== target is 'new'\n")
 
701
                              "=== target is u'new'\n")
708
702
 
709
703
    def test_diff_directory(self):
710
704
        self.build_tree(['new-tree/new-dir/'])
787
781
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
788
782
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
789
783
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
790
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
 
784
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
791
785
                                                         (3,3), (4,4)])
792
786
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
793
787
 
808
802
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
809
803
                                          (4, 6), (5, 7), (6, 8)])
810
804
 
811
 
        # recurse_matches doesn't match non-unique 
 
805
        # recurse_matches doesn't match non-unique
812
806
        # lines surrounded by bogus text.
813
807
        # The update has been done in patiencediff.SequenceMatcher instead
814
808
 
951
945
                 ('delete', 1,2, 1,1),
952
946
                 ('equal',  2,3, 1,2),
953
947
                ])
954
 
        chk_ops('aBccDe', 'abccde', 
 
948
        chk_ops('aBccDe', 'abccde',
955
949
                [('equal',   0,1, 0,1),
956
950
                 ('replace', 1,5, 1,5),
957
951
                 ('equal',   5,6, 5,6),
958
952
                ])
959
 
        chk_ops('aBcDec', 'abcdec', 
 
953
        chk_ops('aBcDec', 'abcdec',
960
954
                [('equal',   0,1, 0,1),
961
955
                 ('replace', 1,2, 1,2),
962
956
                 ('equal',   2,3, 2,3),
963
957
                 ('replace', 3,4, 3,4),
964
958
                 ('equal',   4,6, 4,6),
965
959
                ])
966
 
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
 
960
        chk_ops('aBcdEcdFg', 'abcdecdfg',
967
961
                [('equal',   0,1, 0,1),
968
962
                 ('replace', 1,8, 1,8),
969
963
                 ('equal',   8,9, 8,9)
970
964
                ])
971
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
 
965
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
972
966
                [('equal',   0,1, 0,1),
973
967
                 ('replace', 1,2, 1,2),
974
968
                 ('equal',   2,4, 2,4),
1034
1028
    """
1035
1029
    gnxrf_netf = ['svyr*']
1036
1030
    gnxrf_bcgvbaf = ['ab-erphefr']
1037
 
  
 
1031
 
1038
1032
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1039
1033
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1040
1034
        vs vf_dhvrg():
1048
1042
'''.splitlines(True), '''\
1049
1043
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1050
1044
 
1051
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
 
1045
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
1052
1046
    nqq gurz.
1053
1047
    """
1054
1048
    gnxrf_netf = ['svyr*']
1153
1147
 
1154
1148
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1155
1149
 
1156
 
    _test_needs_features = [CompiledPatienceDiffFeature]
 
1150
    _test_needs_features = [compiled_patiencediff_feature]
1157
1151
 
1158
1152
    def setUp(self):
1159
1153
        super(TestPatienceDiffLib_c, self).setUp()
1249
1243
 
1250
1244
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1251
1245
 
1252
 
    _test_needs_features = [CompiledPatienceDiffFeature]
 
1246
    _test_needs_features = [compiled_patiencediff_feature]
1253
1247
 
1254
1248
    def setUp(self):
1255
1249
        super(TestPatienceDiffLibFiles_c, self).setUp()
1261
1255
class TestUsingCompiledIfAvailable(TestCase):
1262
1256
 
1263
1257
    def test_PatienceSequenceMatcher(self):
1264
 
        if CompiledPatienceDiffFeature.available():
 
1258
        if compiled_patiencediff_feature.available():
1265
1259
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1266
1260
            self.assertIs(PatienceSequenceMatcher_c,
1267
1261
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1271
1265
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1272
1266
 
1273
1267
    def test_unique_lcs(self):
1274
 
        if CompiledPatienceDiffFeature.available():
 
1268
        if compiled_patiencediff_feature.available():
1275
1269
            from bzrlib._patiencediff_c import unique_lcs_c
1276
1270
            self.assertIs(unique_lcs_c,
1277
1271
                          bzrlib.patiencediff.unique_lcs)
1281
1275
                          bzrlib.patiencediff.unique_lcs)
1282
1276
 
1283
1277
    def test_recurse_matches(self):
1284
 
        if CompiledPatienceDiffFeature.available():
 
1278
        if compiled_patiencediff_feature.available():
1285
1279
            from bzrlib._patiencediff_c import recurse_matches_c
1286
1280
            self.assertIs(recurse_matches_c,
1287
1281
                          bzrlib.patiencediff.recurse_matches)
1296
1290
    def test_from_string(self):
1297
1291
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
1298
1292
        self.addCleanup(diff_obj.finish)
1299
 
        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],
 
1293
        self.assertEqual(['diff', '@old_path', '@new_path'],
1300
1294
            diff_obj.command_template)
1301
1295
 
1302
1296
    def test_from_string_u5(self):
1303
 
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
 
1297
        diff_obj = DiffFromTool.from_string('diff "-u 5"', None, None, None)
1304
1298
        self.addCleanup(diff_obj.finish)
1305
 
        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],
 
1299
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1306
1300
                         diff_obj.command_template)
1307
1301
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1308
1302
                         diff_obj._get_command('old-path', 'new-path'))
 
1303
        
 
1304
    def test_from_string_path_with_backslashes(self):
 
1305
        self.requireFeature(BackslashDirSeparatorFeature)
 
1306
        tool = 'C:\\Tools\\Diff.exe'
 
1307
        diff_obj = DiffFromTool.from_string(tool, None, None, None)
 
1308
        self.addCleanup(diff_obj.finish)
 
1309
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
 
1310
                         diff_obj.command_template)
 
1311
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
 
1312
                         diff_obj._get_command('old-path', 'new-path'))
1309
1313
 
1310
1314
    def test_execute(self):
1311
1315
        output = StringIO()
1312
1316
        diff_obj = DiffFromTool(['python', '-c',
1313
 
                                 'print "%(old_path)s %(new_path)s"'],
 
1317
                                 'print "@old_path @new_path"'],
1314
1318
                                None, None, output)
1315
1319
        self.addCleanup(diff_obj.finish)
1316
1320
        diff_obj._execute('old', 'new')
1334
1338
        tree.commit('old tree')
1335
1339
        tree.lock_read()
1336
1340
        self.addCleanup(tree.unlock)
 
1341
        basis_tree = tree.basis_tree()
 
1342
        basis_tree.lock_read()
 
1343
        self.addCleanup(basis_tree.unlock)
1337
1344
        diff_obj = DiffFromTool(['python', '-c',
1338
 
                                 'print "%(old_path)s %(new_path)s"'],
1339
 
                                tree, tree, output)
 
1345
                                 'print "@old_path @new_path"'],
 
1346
                                basis_tree, tree, output)
1340
1347
        diff_obj._prepare_files('file-id', 'file', 'file')
1341
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file', r'old\\file')
1342
 
        self.assertReadableByAttrib(diff_obj._root, 'new\\file', r'new\\file')
 
1348
        # The old content should be readonly
 
1349
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
 
1350
                                    r'R.*old\\file$')
 
1351
        # The new content should use the tree object, not a 'new' file anymore
 
1352
        self.assertEndsWith(tree.basedir, 'work/tree')
 
1353
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1343
1354
 
1344
1355
    def assertReadableByAttrib(self, cwd, relpath, regex):
1345
1356
        proc = subprocess.Popen(['attrib', relpath],
1346
1357
                                stdout=subprocess.PIPE,
1347
1358
                                cwd=cwd)
1348
 
        proc.wait()
1349
 
        result = proc.stdout.read()
1350
 
        self.assertContainsRe(result, regex)
 
1359
        (result, err) = proc.communicate()
 
1360
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1351
1361
 
1352
1362
    def test_prepare_files(self):
1353
1363
        output = StringIO()
1367
1377
        tree.lock_read()
1368
1378
        self.addCleanup(tree.unlock)
1369
1379
        diff_obj = DiffFromTool(['python', '-c',
1370
 
                                 'print "%(old_path)s %(new_path)s"'],
 
1380
                                 'print "@old_path @new_path"'],
1371
1381
                                old_tree, tree, output)
1372
1382
        self.addCleanup(diff_obj.finish)
1373
1383
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1375
1385
                                                     'newname')
1376
1386
        self.assertContainsRe(old_path, 'old/oldname$')
1377
1387
        self.assertEqual(0, os.stat(old_path).st_mtime)
1378
 
        self.assertContainsRe(new_path, 'new/newname$')
 
1388
        self.assertContainsRe(new_path, 'tree/newname$')
1379
1389
        self.assertFileEqual('oldcontent', old_path)
1380
1390
        self.assertFileEqual('newcontent', new_path)
1381
1391
        if osutils.host_os_dereferences_symlinks():
1382
1392
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1383
1393
        # make sure we can create files with the same parent directories
1384
1394
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
 
1395
 
 
1396
 
 
1397
class TestGetTreesAndBranchesToDiff(TestCaseWithTransport):
 
1398
 
 
1399
    def test_basic(self):
 
1400
        tree = self.make_branch_and_tree('tree')
 
1401
        (old_tree, new_tree,
 
1402
         old_branch, new_branch,
 
1403
         specific_files, extra_trees) = \
 
1404
            get_trees_and_branches_to_diff(['tree'], None, None, None)
 
1405
 
 
1406
        self.assertIsInstance(old_tree, RevisionTree)
 
1407
        #print dir (old_tree)
 
1408
        self.assertEqual(_mod_revision.NULL_REVISION, old_tree.get_revision_id())
 
1409
        self.assertEqual(tree.basedir, new_tree.basedir)
 
1410
        self.assertEqual(tree.branch.base, old_branch.base)
 
1411
        self.assertEqual(tree.branch.base, new_branch.base)
 
1412
        self.assertIs(None, specific_files)
 
1413
        self.assertIs(None, extra_trees)
 
1414
 
 
1415
    def test_with_rev_specs(self):
 
1416
        tree = self.make_branch_and_tree('tree')
 
1417
        self.build_tree_contents([('tree/file', 'oldcontent')])
 
1418
        tree.add('file', 'file-id')
 
1419
        tree.commit('old tree', timestamp=0, rev_id="old-id")
 
1420
        self.build_tree_contents([('tree/file', 'newcontent')])
 
1421
        tree.commit('new tree', timestamp=0, rev_id="new-id")
 
1422
 
 
1423
        revisions = [RevisionSpec.from_string('1'),
 
1424
                     RevisionSpec.from_string('2')]
 
1425
        (old_tree, new_tree,
 
1426
         old_branch, new_branch,
 
1427
         specific_files, extra_trees) = \
 
1428
            get_trees_and_branches_to_diff(['tree'], revisions, None, None)
 
1429
 
 
1430
        self.assertIsInstance(old_tree, RevisionTree)
 
1431
        self.assertEqual("old-id", old_tree.get_revision_id())
 
1432
        self.assertIsInstance(new_tree, RevisionTree)
 
1433
        self.assertEqual("new-id", new_tree.get_revision_id())
 
1434
        self.assertEqual(tree.branch.base, old_branch.base)
 
1435
        self.assertEqual(tree.branch.base, new_branch.base)
 
1436
        self.assertIs(None, specific_files)
 
1437
        self.assertEqual(tree.basedir, extra_trees[0].basedir)