~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

• browse files at revision 5029.1.1
• compare with another revision
• download diff
• download tarball
• view history from revision 5029.1.1

• reverse the comparison (5029.1.1 to 4595.7.3)
• stop comparing with revision 4595.7.3

Show diffs side-by-side

added

removed

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

44

47

 

45

48

 

46

49

class _AttribFeature(Feature):

60

63

AttribFeature = _AttribFeature()

61

64

 

62

65

 

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()

 

66

compiled_patiencediff_feature = tests.ModuleAvailableFeature(

 

67

                                    'bzrlib._patiencediff_c')

76

68

 

77

69

 

78

70

def udiff_lines(old, new, allow_binary=False):

1153

1145

 

1154

1146

class TestPatienceDiffLib_c(TestPatienceDiffLib):

1155

1147

 

1156

 

    _test_needs_features = [CompiledPatienceDiffFeature]

 

1148

    _test_needs_features = [compiled_patiencediff_feature]

1157

1149

 

1158

1150

    def setUp(self):

1159

1151

        super(TestPatienceDiffLib_c, self).setUp()

1249

1241

 

1250

1242

class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):

1251

1243

 

1252

 

    _test_needs_features = [CompiledPatienceDiffFeature]

 

1244

    _test_needs_features = [compiled_patiencediff_feature]

1253

1245

 

1254

1246

    def setUp(self):

1255

1247

        super(TestPatienceDiffLibFiles_c, self).setUp()

1261

1253

class TestUsingCompiledIfAvailable(TestCase):

1262

1254

 

1263

1255

    def test_PatienceSequenceMatcher(self):

1264

 

        if CompiledPatienceDiffFeature.available():

 

1256

        if compiled_patiencediff_feature.available():

1265

1257

            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c

1266

1258

            self.assertIs(PatienceSequenceMatcher_c,

1267

1259

                          bzrlib.patiencediff.PatienceSequenceMatcher)

1271

1263

                          bzrlib.patiencediff.PatienceSequenceMatcher)

1272

1264

 

1273

1265

    def test_unique_lcs(self):

1274

 

        if CompiledPatienceDiffFeature.available():

 

1266

        if compiled_patiencediff_feature.available():

1275

1267

            from bzrlib._patiencediff_c import unique_lcs_c

1276

1268

            self.assertIs(unique_lcs_c,

1277

1269

                          bzrlib.patiencediff.unique_lcs)

1281

1273

                          bzrlib.patiencediff.unique_lcs)

1282

1274

 

1283

1275

    def test_recurse_matches(self):

1284

 

        if CompiledPatienceDiffFeature.available():

 

1276

        if compiled_patiencediff_feature.available():

1285

1277

            from bzrlib._patiencediff_c import recurse_matches_c

1286

1278

            self.assertIs(recurse_matches_c,

1287

1279

                          bzrlib.patiencediff.recurse_matches)

1296

1288

    def test_from_string(self):

1297

1289

        diff_obj = DiffFromTool.from_string('diff', None, None, None)

1298

1290

        self.addCleanup(diff_obj.finish)

1299

 

        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],

 

1291

        self.assertEqual(['diff', '@old_path', '@new_path'],

1300

1292

            diff_obj.command_template)

1301

1293

 

1302

1294

    def test_from_string_u5(self):

1303

1295

        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)

1304

1296

        self.addCleanup(diff_obj.finish)

1305

 

        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],

 

1297

        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],

1306

1298

                         diff_obj.command_template)

1307

1299

        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],

1308

1300

                         diff_obj._get_command('old-path', 'new-path'))

1310

1302

    def test_execute(self):

1311

1303

        output = StringIO()

1312

1304

        diff_obj = DiffFromTool(['python', '-c',

1313

 

                                 'print "%(old_path)s %(new_path)s"'],

 

1305

                                 'print "@old_path @new_path"'],

1314

1306

                                None, None, output)

1315

1307

        self.addCleanup(diff_obj.finish)

1316

1308

        diff_obj._execute('old', 'new')

1334

1326

        tree.commit('old tree')

1335

1327

        tree.lock_read()

1336

1328

        self.addCleanup(tree.unlock)

 

1329

        basis_tree = tree.basis_tree()

 

1330

        basis_tree.lock_read()

 

1331

        self.addCleanup(basis_tree.unlock)

1337

1332

        diff_obj = DiffFromTool(['python', '-c',

1338

 

                                 'print "%(old_path)s %(new_path)s"'],

1339

 

                                tree, tree, output)

 

1333

                                 'print "@old_path @new_path"'],

 

1334

                                basis_tree, tree, output)

1340

1335

        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')

 

1336

        # The old content should be readonly

 

1337

        self.assertReadableByAttrib(diff_obj._root, 'old\\file',

 

1338

                                    r'R.*old\\file$')

 

1339

        # The new content should use the tree object, not a 'new' file anymore

 

1340

        self.assertEndsWith(tree.basedir, 'work/tree')

 

1341

        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')

1343

1342

 

1344

1343

    def assertReadableByAttrib(self, cwd, relpath, regex):

1345

1344

        proc = subprocess.Popen(['attrib', relpath],

1346

1345

                                stdout=subprocess.PIPE,

1347

1346

                                cwd=cwd)

1348

 

        proc.wait()

1349

 

        result = proc.stdout.read()

1350

 

        self.assertContainsRe(result, regex)

 

1347

        (result, err) = proc.communicate()

 

1348

        self.assertContainsRe(result.replace('\r\n', '\n'), regex)

1351

1349

 

1352

1350

    def test_prepare_files(self):

1353

1351

        output = StringIO()

1367

1365

        tree.lock_read()

1368

1366

        self.addCleanup(tree.unlock)

1369

1367

        diff_obj = DiffFromTool(['python', '-c',

1370

 

                                 'print "%(old_path)s %(new_path)s"'],

 

1368

                                 'print "@old_path @new_path"'],

1371

1369

                                old_tree, tree, output)

1372

1370

        self.addCleanup(diff_obj.finish)

1373

1371

        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')

1375

1373

                                                     'newname')

1376

1374

        self.assertContainsRe(old_path, 'old/oldname$')

1377

1375

        self.assertEqual(0, os.stat(old_path).st_mtime)

1378

 

        self.assertContainsRe(new_path, 'new/newname$')

 

1376

        self.assertContainsRe(new_path, 'tree/newname$')

1379

1377

        self.assertFileEqual('oldcontent', old_path)

1380

1378

        self.assertFileEqual('newcontent', new_path)

1381

1379

        if osutils.host_os_dereferences_symlinks():

1382

1380

            self.assertTrue(os.path.samefile('tree/newname', new_path))

1383

1381

        # make sure we can create files with the same parent directories

1384

1382

        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')

 

1383

 

 

1384

 

 

1385

class TestGetTreesAndBranchesToDiff(TestCaseWithTransport):

 

1386

 

 

1387

    def test_basic(self):

 

1388

        tree = self.make_branch_and_tree('tree')

 

1389

        (old_tree, new_tree,

 

1390

         old_branch, new_branch,

 

1391

         specific_files, extra_trees) = \

 

1392

            get_trees_and_branches_to_diff(['tree'], None, None, None)

 

1393

 

 

1394

        self.assertIsInstance(old_tree, RevisionTree)

 

1395

        #print dir (old_tree)

 

1396

        self.assertEqual(_mod_revision.NULL_REVISION, old_tree.get_revision_id())

 

1397

        self.assertEqual(tree.basedir, new_tree.basedir)

 

1398

        self.assertEqual(tree.branch.base, old_branch.base)

 

1399

        self.assertEqual(tree.branch.base, new_branch.base)

 

1400

        self.assertIs(None, specific_files)

 

1401

        self.assertIs(None, extra_trees)

 

1402

 

 

1403

    def test_with_rev_specs(self):

 

1404

        tree = self.make_branch_and_tree('tree')

 

1405

        self.build_tree_contents([('tree/file', 'oldcontent')])

 

1406

        tree.add('file', 'file-id')

 

1407

        tree.commit('old tree', timestamp=0, rev_id="old-id")

 

1408

        self.build_tree_contents([('tree/file', 'newcontent')])

 

1409

        tree.commit('new tree', timestamp=0, rev_id="new-id")

 

1410

 

 

1411

        revisions = [RevisionSpec.from_string('1'),

 

1412

                     RevisionSpec.from_string('2')]

 

1413

        (old_tree, new_tree,

 

1414

         old_branch, new_branch,

 

1415

         specific_files, extra_trees) = \

 

1416

            get_trees_and_branches_to_diff(['tree'], revisions, None, None)

 

1417

 

 

1418

        self.assertIsInstance(old_tree, RevisionTree)

 

1419

        self.assertEqual("old-id", old_tree.get_revision_id())

 

1420

        self.assertIsInstance(new_tree, RevisionTree)

 

1421

        self.assertEqual("new-id", new_tree.get_revision_id())

 

1422

        self.assertEqual(tree.branch.base, old_branch.base)

 

1423

        self.assertEqual(tree.branch.base, new_branch.base)

 

1424

        self.assertIs(None, specific_files)

 

1425

        self.assertEqual(tree.basedir, extra_trees[0].basedir)

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1