~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import os

import os.path

from cStringIO import StringIO

import errno

import subprocess

import sys

from tempfile import TemporaryFile

from bzrlib import tests

from bzrlib.diff import (

    DiffFromTool,

    DiffPath,

    DiffSymlink,

    DiffTree,

    DiffText,

    external_diff,

    internal_diff,

    show_diff_trees,

    )

from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing

import bzrlib.osutils as osutils

import bzrlib.transform as transform

import bzrlib.patiencediff

import bzrlib._patiencediff_py

from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,

                          TestCaseInTempDir, TestSkipped)

class _AttribFeature(Feature):

    def _probe(self):

        if (sys.platform not in ('cygwin', 'win32')):

            return False

        try:

            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)

        except OSError, e:

            return False

        return (0 == proc.wait())

    def feature_name(self):

        return 'attrib Windows command-line tool'

AttribFeature = _AttribFeature()

class _CompiledPatienceDiffFeature(Feature):

    def _probe(self):

        try:

            import bzrlib._patiencediff_c

        except ImportError:

            return False

        return True

    def feature_name(self):

        return 'bzrlib._patiencediff_c'

CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()

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

    output = StringIO()

    internal_diff('old', old, 'new', new, output, allow_binary)

    output.seek(0, 0)

    return output.readlines()

def external_udiff_lines(old, new, use_stringio=False):

    if use_stringio:

        # StringIO has no fileno, so it tests a different codepath

        output = StringIO()

    else:

        output = TemporaryFile()

    try:

        external_diff('old', old, 'new', new, output, diff_opts=['-u'])

    except NoDiff:

        raise TestSkipped('external "diff" not present to test')

    output.seek(0, 0)

    lines = output.readlines()

    output.close()

    return lines

class TestDiff(TestCase):

    def test_add_nl(self):

        """diff generates a valid diff for patches that add a newline"""

        lines = udiff_lines(['boo'], ['boo\n'])

        self.check_patch(lines)

        self.assertEquals(lines[4], '\\ No newline at end of file\n')

            ## "expected no-nl, got %r" % lines[4]

    def test_add_nl_2(self):

        """diff generates a valid diff for patches that change last line and

        add a newline.

        """

        lines = udiff_lines(['boo'], ['goo\n'])

        self.check_patch(lines)

        self.assertEquals(lines[4], '\\ No newline at end of file\n')

            ## "expected no-nl, got %r" % lines[4]

    def test_remove_nl(self):

        """diff generates a valid diff for patches that change last line and

        add a newline.

        """

        lines = udiff_lines(['boo\n'], ['boo'])

        self.check_patch(lines)

        self.assertEquals(lines[5], '\\ No newline at end of file\n')

            ## "expected no-nl, got %r" % lines[5]

    def check_patch(self, lines):

        self.assert_(len(lines) > 1)

            ## "Not enough lines for a file header for patch:\n%s" % "".join(lines)

        self.assert_(lines[0].startswith ('---'))

            ## 'No orig line for patch:\n%s' % "".join(lines)

        self.assert_(lines[1].startswith ('+++'))

            ## 'No mod line for patch:\n%s' % "".join(lines)

        self.assert_(len(lines) > 2)

            ## "No hunks for patch:\n%s" % "".join(lines)

        self.assert_(lines[2].startswith('@@'))

            ## "No hunk header for patch:\n%s" % "".join(lines)

        self.assert_('@@' in lines[2][2:])

            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)

    def test_binary_lines(self):

        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])

        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])

        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)

        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)

    def test_external_diff(self):

        lines = external_udiff_lines(['boo\n'], ['goo\n'])

        self.check_patch(lines)

        self.assertEqual('\n', lines[-1])

    def test_external_diff_no_fileno(self):

        # Make sure that we can handle not having a fileno, even

        # if the diff is large

        lines = external_udiff_lines(['boo\n']*10000,

                                     ['goo\n']*10000,

                                     use_stringio=True)

        self.check_patch(lines)

    def test_external_diff_binary_lang_c(self):

        old_env = {}

        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):

            old_env[lang] = osutils.set_or_unset_env(lang, 'C')

        try:

            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])

            # Older versions of diffutils say "Binary files", newer

            # versions just say "Files".

            self.assertContainsRe(lines[0],

                                  '(Binary f|F)iles old and new differ\n')

            self.assertEquals(lines[1:], ['\n'])

        finally:

            for lang, old_val in old_env.iteritems():

                osutils.set_or_unset_env(lang, old_val)

    def test_no_external_diff(self):

        """Check that NoDiff is raised when diff is not available"""

        # Use os.environ['PATH'] to make sure no 'diff' command is available

        orig_path = os.environ['PATH']

        try:

            os.environ['PATH'] = ''

            self.assertRaises(NoDiff, external_diff,

                              'old', ['boo\n'], 'new', ['goo\n'],

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

        finally:

            os.environ['PATH'] = orig_path

    def test_internal_diff_default(self):

        # Default internal diff encoding is utf8

        output = StringIO()

        internal_diff(u'old_\xb5', ['old_text\n'],

                    u'new_\xe5', ['new_text\n'], output)

        lines = output.getvalue().splitlines(True)

        self.check_patch(lines)

        self.assertEquals(['--- old_\xc2\xb5\n',

                           '+++ new_\xc3\xa5\n',

                           '@@ -1,1 +1,1 @@\n',

                           '-old_text\n',

                           '+new_text\n',

                           '\n',

                          ]

                          , lines)

    def test_internal_diff_utf8(self):

        output = StringIO()

        internal_diff(u'old_\xb5', ['old_text\n'],

                    u'new_\xe5', ['new_text\n'], output,

                    path_encoding='utf8')

        lines = output.getvalue().splitlines(True)

        self.check_patch(lines)

        self.assertEquals(['--- old_\xc2\xb5\n',

                           '+++ new_\xc3\xa5\n',

                           '@@ -1,1 +1,1 @@\n',

                           '-old_text\n',

                           '+new_text\n',

                           '\n',

                          ]

                          , lines)

    def test_internal_diff_iso_8859_1(self):

        output = StringIO()

        internal_diff(u'old_\xb5', ['old_text\n'],

                    u'new_\xe5', ['new_text\n'], output,

                    path_encoding='iso-8859-1')

        lines = output.getvalue().splitlines(True)

        self.check_patch(lines)

        self.assertEquals(['--- old_\xb5\n',

                           '+++ new_\xe5\n',

                           '@@ -1,1 +1,1 @@\n',

                           '-old_text\n',

                           '+new_text\n',

                           '\n',

                          ]

                          , lines)

    def test_internal_diff_no_content(self):

        output = StringIO()

        internal_diff(u'old', [], u'new', [], output)

        self.assertEqual('', output.getvalue())

    def test_internal_diff_no_changes(self):

        output = StringIO()

        internal_diff(u'old', ['text\n', 'contents\n'],

                      u'new', ['text\n', 'contents\n'],

                      output)

        self.assertEqual('', output.getvalue())

    def test_internal_diff_returns_bytes(self):

        import StringIO

        output = StringIO.StringIO()

        internal_diff(u'old_\xb5', ['old_text\n'],

                    u'new_\xe5', ['new_text\n'], output)

        self.failUnless(isinstance(output.getvalue(), str),

            'internal_diff should return bytestrings')

class TestDiffFiles(TestCaseInTempDir):

    def test_external_diff_binary(self):

        """The output when using external diff should use diff's i18n error"""

        # Make sure external_diff doesn't fail in the current LANG

        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])

        cmd = ['diff', '-u', '--binary', 'old', 'new']

        open('old', 'wb').write('\x00foobar\n')

        open('new', 'wb').write('foo\x00bar\n')

        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,

                                     stdin=subprocess.PIPE)

        out, err = pipe.communicate()

        # Diff returns '2' on Binary files.

        self.assertEqual(2, pipe.returncode)

        # We should output whatever diff tells us, plus a trailing newline

        self.assertEqual(out.splitlines(True) + ['\n'], lines)

class TestShowDiffTreesHelper(TestCaseWithTransport):

    """Has a helper for running show_diff_trees"""

    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):

        output = StringIO()

        if working_tree is not None:

            extra_trees = (working_tree,)

        else:

            extra_trees = ()

        show_diff_trees(tree1, tree2, output, specific_files=specific_files,

                        extra_trees=extra_trees, old_label='old/',

                        new_label='new/')

        return output.getvalue()

class TestDiffDates(TestShowDiffTreesHelper):

    def setUp(self):

        super(TestDiffDates, self).setUp()

        self.wt = self.make_branch_and_tree('.')

        self.b = self.wt.branch

        self.build_tree_contents([

            ('file1', 'file1 contents at rev 1\n'),

            ('file2', 'file2 contents at rev 1\n')

            ])

        self.wt.add(['file1', 'file2'])

        self.wt.commit(

            message='Revision 1',

            timestamp=1143849600, # 2006-04-01 00:00:00 UTC

            timezone=0,

            rev_id='rev-1')

        self.build_tree_contents([('file1', 'file1 contents at rev 2\n')])

        self.wt.commit(

            message='Revision 2',

            timestamp=1143936000, # 2006-04-02 00:00:00 UTC

            timezone=28800,

            rev_id='rev-2')

        self.build_tree_contents([('file2', 'file2 contents at rev 3\n')])

        self.wt.commit(

            message='Revision 3',

            timestamp=1144022400, # 2006-04-03 00:00:00 UTC

            timezone=-3600,

            rev_id='rev-3')

        self.wt.remove(['file2'])

        self.wt.commit(

            message='Revision 4',

            timestamp=1144108800, # 2006-04-04 00:00:00 UTC

            timezone=0,

            rev_id='rev-4')

        self.build_tree_contents([

            ('file1', 'file1 contents in working tree\n')

            ])

        # set the date stamps for files in the working tree to known values

        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC

    def test_diff_rev_tree_working_tree(self):

        output = self.get_diff(self.wt.basis_tree(), self.wt)

        # note that the date for old/file1 is from rev 2 rather than from

        # the basis revision (rev 4)

        self.assertEqualDiff(output, '''\

=== modified file 'file1'

--- old/file1\t2006-04-02 00:00:00 +0000

+++ new/file1\t2006-04-05 00:00:00 +0000

@@ -1,1 +1,1 @@

-file1 contents at rev 2

+file1 contents in working tree

''')

    def test_diff_rev_tree_rev_tree(self):

        tree1 = self.b.repository.revision_tree('rev-2')

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

        output = self.get_diff(tree1, tree2)

        self.assertEqualDiff(output, '''\

=== modified file 'file2'

--- old/file2\t2006-04-01 00:00:00 +0000

+++ new/file2\t2006-04-03 00:00:00 +0000

@@ -1,1 +1,1 @@

-file2 contents at rev 1

+file2 contents at rev 3

''')

    def test_diff_add_files(self):

        tree1 = self.b.repository.revision_tree(None)

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

        output = self.get_diff(tree1, tree2)

        # the files have the epoch time stamp for the tree in which

        # they don't exist.

        self.assertEqualDiff(output, '''\

=== added file 'file1'

--- old/file1\t1970-01-01 00:00:00 +0000

+++ new/file1\t2006-04-01 00:00:00 +0000

@@ -0,0 +1,1 @@

+file1 contents at rev 1

=== added file 'file2'

--- old/file2\t1970-01-01 00:00:00 +0000

+++ new/file2\t2006-04-01 00:00:00 +0000

@@ -0,0 +1,1 @@

+file2 contents at rev 1

''')

    def test_diff_remove_files(self):

        tree1 = self.b.repository.revision_tree('rev-3')

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

        output = self.get_diff(tree1, tree2)

        # the file has the epoch time stamp for the tree in which

        # it doesn't exist.

        self.assertEqualDiff(output, '''\

=== removed file 'file2'

--- old/file2\t2006-04-03 00:00:00 +0000

+++ new/file2\t1970-01-01 00:00:00 +0000

@@ -1,1 +0,0 @@

-file2 contents at rev 3

''')

    def test_show_diff_specified(self):

        """A working tree filename can be used to identify a file"""

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

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

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

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

                            working_tree=self.wt)

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

    def test_recursive_diff(self):

        """Children of directories are matched"""

        os.mkdir('dir1')

        os.mkdir('dir2')

        self.wt.add(['dir1', 'dir2'])

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

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

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

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

                            working_tree=self.wt)

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

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

                            working_tree=self.wt)

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

class TestShowDiffTrees(TestShowDiffTreesHelper):

    """Direct tests for show_diff_trees"""

    def test_modified_file(self):

        """Test when a file is modified."""

        tree = self.make_branch_and_tree('tree')

        self.build_tree_contents([('tree/file', 'contents\n')])

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

        tree.commit('one', rev_id='rev-1')

        self.build_tree_contents([('tree/file', 'new contents\n')])

        diff = self.get_diff(tree.basis_tree(), tree)

        self.assertContainsRe(diff, "=== modified file 'file'\n")

        self.assertContainsRe(diff, '--- old/file\t')

        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')

        self.assertContainsRe(diff, '-contents\n'

                                    '\\+new contents\n')

    def test_modified_file_in_renamed_dir(self):

        """Test when a file is modified in a renamed directory."""

        tree = self.make_branch_and_tree('tree')

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

        self.build_tree_contents([('tree/dir/file', 'contents\n')])

        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])

        tree.commit('one', rev_id='rev-1')

        tree.rename_one('dir', 'other')

        self.build_tree_contents([('tree/other/file', 'new contents\n')])

        diff = self.get_diff(tree.basis_tree(), tree)

        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")

        self.assertContainsRe(diff, "=== modified file 'other/file'\n")

        # XXX: This is technically incorrect, because it used to be at another

        # location. What to do?

        self.assertContainsRe(diff, '--- old/dir/file\t')

        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')

        self.assertContainsRe(diff, '-contents\n'

                                    '\\+new contents\n')

    def test_renamed_directory(self):

        """Test when only a directory is only renamed."""

        tree = self.make_branch_and_tree('tree')

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

        self.build_tree_contents([('tree/dir/file', 'contents\n')])

        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])

        tree.commit('one', rev_id='rev-1')

        tree.rename_one('dir', 'newdir')

        diff = self.get_diff(tree.basis_tree(), tree)

        # Renaming a directory should be a single "you renamed this dir" even

        # when there are files inside.

        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)

    def test_renamed_file(self):

        """Test when a file is only renamed."""

        tree = self.make_branch_and_tree('tree')

        self.build_tree_contents([('tree/file', 'contents\n')])

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

        tree.commit('one', rev_id='rev-1')

        tree.rename_one('file', 'newname')

        diff = self.get_diff(tree.basis_tree(), tree)

        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")

        # We shouldn't have a --- or +++ line, because there is no content

        # change

        self.assertNotContainsRe(diff, '---')

    def test_renamed_and_modified_file(self):

        """Test when a file is only renamed."""

        tree = self.make_branch_and_tree('tree')

        self.build_tree_contents([('tree/file', 'contents\n')])

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

        tree.commit('one', rev_id='rev-1')

        tree.rename_one('file', 'newname')

        self.build_tree_contents([('tree/newname', 'new contents\n')])

        diff = self.get_diff(tree.basis_tree(), tree)

        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")

        self.assertContainsRe(diff, '--- old/file\t')

        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')

        self.assertContainsRe(diff, '-contents\n'

                                    '\\+new contents\n')

    def test_internal_diff_exec_property(self):

        tree = self.make_branch_and_tree('tree')

        tt = transform.TreeTransform(tree)

        tt.new_file('a', tt.root, 'contents\n', 'a-id', True)

        tt.new_file('b', tt.root, 'contents\n', 'b-id', False)

        tt.new_file('c', tt.root, 'contents\n', 'c-id', True)

        tt.new_file('d', tt.root, 'contents\n', 'd-id', False)

        tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)

        tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)

        tt.apply()

        tree.commit('one', rev_id='rev-1')

        tt = transform.TreeTransform(tree)

        tt.set_executability(False, tt.trans_id_file_id('a-id'))

        tt.set_executability(True, tt.trans_id_file_id('b-id'))

        tt.set_executability(False, tt.trans_id_file_id('c-id'))

        tt.set_executability(True, tt.trans_id_file_id('d-id'))

        tt.apply()

        tree.rename_one('c', 'new-c')

        tree.rename_one('d', 'new-d')

        diff = self.get_diff(tree.basis_tree(), tree)

        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")

        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")

        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")

        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")

        self.assertNotContainsRe(diff, r"file 'e'")

        self.assertNotContainsRe(diff, r"file 'f'")

    def test_binary_unicode_filenames(self):

        """Test that contents of files are *not* encoded in UTF-8 when there

        is a binary file in the diff.

        """

        # See https://bugs.launchpad.net/bugs/110092.

        self.requireFeature(tests.UnicodeFilenameFeature)

        # This bug isn't triggered with cStringIO.

        from StringIO import StringIO

        tree = self.make_branch_and_tree('tree')

        alpha, omega = u'\u03b1', u'\u03c9'

        alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')

        self.build_tree_contents(

            [('tree/' + alpha, chr(0)),

             ('tree/' + omega,

              ('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])

        tree.add([alpha], ['file-id'])

        tree.add([omega], ['file-id-2'])

        diff_content = StringIO()

        show_diff_trees(tree.basis_tree(), tree, diff_content)

        diff = diff_content.getvalue()

        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)

        self.assertContainsRe(

            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))

        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)

        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))

        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))

    def test_unicode_filename(self):

        """Test when the filename are unicode."""

        self.requireFeature(tests.UnicodeFilenameFeature)

        alpha, omega = u'\u03b1', u'\u03c9'

        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')

        tree = self.make_branch_and_tree('tree')

        self.build_tree_contents([('tree/ren_'+alpha, 'contents\n')])

        tree.add(['ren_'+alpha], ['file-id-2'])

        self.build_tree_contents([('tree/del_'+alpha, 'contents\n')])

        tree.add(['del_'+alpha], ['file-id-3'])

        self.build_tree_contents([('tree/mod_'+alpha, 'contents\n')])

        tree.add(['mod_'+alpha], ['file-id-4'])

        tree.commit('one', rev_id='rev-1')

        tree.rename_one('ren_'+alpha, 'ren_'+omega)

        tree.remove('del_'+alpha)

        self.build_tree_contents([('tree/add_'+alpha, 'contents\n')])

        tree.add(['add_'+alpha], ['file-id'])

        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])

        diff = self.get_diff(tree.basis_tree(), tree)

        self.assertContainsRe(diff,

                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))

        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)

        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)

        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)

class DiffWasIs(DiffPath):

    def diff(self, file_id, old_path, new_path, old_kind, new_kind):

        self.to_file.write('was: ')

        self.to_file.write(self.old_tree.get_file(file_id).read())

        self.to_file.write('is: ')

        self.to_file.write(self.new_tree.get_file(file_id).read())

        pass

class TestDiffTree(TestCaseWithTransport):

    def setUp(self):

        TestCaseWithTransport.setUp(self)

        self.old_tree = self.make_branch_and_tree('old-tree')

        self.old_tree.lock_write()

        self.addCleanup(self.old_tree.unlock)

        self.new_tree = self.make_branch_and_tree('new-tree')

        self.new_tree.lock_write()

        self.addCleanup(self.new_tree.unlock)

        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())

    def test_diff_text(self):

        self.build_tree_contents([('old-tree/olddir/',),

                                  ('old-tree/olddir/oldfile', 'old\n')])

        self.old_tree.add('olddir')

        self.old_tree.add('olddir/oldfile', 'file-id')

        self.build_tree_contents([('new-tree/newdir/',),

                                  ('new-tree/newdir/newfile', 'new\n')])

        self.new_tree.add('newdir')

        self.new_tree.add('newdir/newfile', 'file-id')

        differ = DiffText(self.old_tree, self.new_tree, StringIO())

        differ.diff_text('file-id', None, 'old label', 'new label')