← 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: Gordon Tyler
  • Date: 2010-02-02 06:30:43 UTC
  • mto: (5037.3.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5046.
  • Revision ID: gordon@doxxx.net-20100202063043-3ygr1114d25m3f7m
Added cmdline.split function, which replaces commands.shlex_split_unicode.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
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):
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/'])
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)