~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

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

• reverse the comparison (5020.1.1 to 3985.2.5)
• stop comparing with revision 3985.2.5

Show diffs side-by-side

added

removed

bzrlib/tests/test_diff.py

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

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

184

176

                              StringIO(), diff_opts=['-u'])

185

177

        finally:

186

178

            os.environ['PATH'] = orig_path

187

 

        

 

179

 

188

180

    def test_internal_diff_default(self):

189

181

        # Default internal diff encoding is utf8

190

182

        output = StringIO()

355

347

+file2 contents at rev 3

356

348

 

357

349

''')

358

 

        

 

350

 

359

351

    def test_diff_add_files(self):

360

352

        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)

361

353

        tree2 = self.b.repository.revision_tree('rev-1')

397

389

        self.wt.rename_one('file1', 'file1b')

398

390

        old_tree = self.b.repository.revision_tree('rev-1')

399

391

        new_tree = self.b.repository.revision_tree('rev-4')

400

 

        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 

 

392

        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],

401

393

                            working_tree=self.wt)

402

394

        self.assertContainsRe(out, 'file1\t')

403

395

 

409

401

        self.wt.rename_one('file1', 'dir1/file1')

410

402

        old_tree = self.b.repository.revision_tree('rev-1')

411

403

        new_tree = self.b.repository.revision_tree('rev-4')

412

 

        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 

 

404

        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],

413

405

                            working_tree=self.wt)

414

406

        self.assertContainsRe(out, 'file1\t')

415

 

        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 

 

407

        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],

416

408

                            working_tree=self.wt)

417

409

        self.assertNotContainsRe(out, 'file1\t')

418

410

 

704

696

            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'

705

697

             ' \@\@\n-old\n\n')

706

698

        self.assertContainsRe(self.differ.to_file.getvalue(),

707

 

                              "=== target is 'new'\n")

 

699

                              "=== target is u'new'\n")

708

700

 

709

701

    def test_diff_directory(self):

710

702

        self.build_tree(['new-tree/new-dir/'])

787

779

        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])

788

780

        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])

789

781

        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])

790

 

        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 

 

782

        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),

791

783

                                                         (3,3), (4,4)])

792

784

        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])

793

785

 

808

800

        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),

809

801

                                          (4, 6), (5, 7), (6, 8)])

810

802

 

811

 

        # recurse_matches doesn't match non-unique 

 

803

        # recurse_matches doesn't match non-unique

812

804

        # lines surrounded by bogus text.

813

805

        # The update has been done in patiencediff.SequenceMatcher instead

814

806

 

951

943

                 ('delete', 1,2, 1,1),

952

944

                 ('equal',  2,3, 1,2),

953

945

                ])

954

 

        chk_ops('aBccDe', 'abccde', 

 

946

        chk_ops('aBccDe', 'abccde',

955

947

                [('equal',   0,1, 0,1),

956

948

                 ('replace', 1,5, 1,5),

957

949

                 ('equal',   5,6, 5,6),

958

950

                ])

959

 

        chk_ops('aBcDec', 'abcdec', 

 

951

        chk_ops('aBcDec', 'abcdec',

960

952

                [('equal',   0,1, 0,1),

961

953

                 ('replace', 1,2, 1,2),

962

954

                 ('equal',   2,3, 2,3),

963

955

                 ('replace', 3,4, 3,4),

964

956

                 ('equal',   4,6, 4,6),

965

957

                ])

966

 

        chk_ops('aBcdEcdFg', 'abcdecdfg', 

 

958

        chk_ops('aBcdEcdFg', 'abcdecdfg',

967

959

                [('equal',   0,1, 0,1),

968

960

                 ('replace', 1,8, 1,8),

969

961

                 ('equal',   8,9, 8,9)

970

962

                ])

971

 

        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 

 

963

        chk_ops('aBcdEeXcdFg', 'abcdecdfg',

972

964

                [('equal',   0,1, 0,1),

973

965

                 ('replace', 1,2, 1,2),

974

966

                 ('equal',   2,4, 2,4),

1034

1026

    """

1035

1027

    gnxrf_netf = ['svyr*']

1036

1028

    gnxrf_bcgvbaf = ['ab-erphefr']

1037

 

  

 

1029

 

1038

1030

    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):

1039

1031

        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy

1040

1032

        vs vf_dhvrg():

1048

1040

'''.splitlines(True), '''\

1049

1041

    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.

1050

1042

 

1051

 

    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 

 

1043

    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl

1052

1044

    nqq gurz.

1053

1045

    """

1054

1046

    gnxrf_netf = ['svyr*']

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