← 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: Martin Pool
  • Date: 2008-05-01 02:42:46 UTC
  • mto: (3360.3.4 1.4)
  • mto: This revision was merged to the branch mainline in revision 3401.
  • Revision ID: mbp@sourcefrog.net-20080501024246-x13lcwcda0h7j49f
merge fix and test for #214894

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2012, 2014, 2016 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
import os
 
18
import os.path
18
19
from cStringIO import StringIO
 
20
import errno
19
21
import subprocess
20
 
import tempfile
 
22
from tempfile import TemporaryFile
21
23
 
22
 
from bzrlib import (
23
 
    diff,
24
 
    errors,
25
 
    osutils,
26
 
    patiencediff,
27
 
    _patiencediff_py,
28
 
    revision as _mod_revision,
29
 
    revisionspec,
30
 
    revisiontree,
31
 
    tests,
32
 
    transform,
 
24
from bzrlib import tests
 
25
from bzrlib.diff import (
 
26
    DiffFromTool,
 
27
    DiffPath,
 
28
    DiffSymlink,
 
29
    DiffTree,
 
30
    DiffText,
 
31
    external_diff,
 
32
    internal_diff,
 
33
    show_diff_trees,
33
34
    )
34
 
from bzrlib.tests import (
35
 
    features,
36
 
    EncodingAdapter,
37
 
)
38
 
from bzrlib.tests.blackbox.test_diff import subst_dates
39
 
from bzrlib.tests.scenarios import load_tests_apply_scenarios
40
 
 
41
 
 
42
 
load_tests = load_tests_apply_scenarios
43
 
 
 
35
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
 
36
import bzrlib.osutils as osutils
 
37
import bzrlib.transform as transform
 
38
import bzrlib.patiencediff
 
39
import bzrlib._patiencediff_py
 
40
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
41
                          TestCaseInTempDir, TestSkipped)
 
42
 
 
43
 
 
44
class _CompiledPatienceDiffFeature(Feature):
 
45
 
 
46
    def _probe(self):
 
47
        try:
 
48
            import bzrlib._patiencediff_c
 
49
        except ImportError:
 
50
            return False
 
51
        return True
 
52
 
 
53
    def feature_name(self):
 
54
        return 'bzrlib._patiencediff_c'
 
55
 
 
56
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
 
57
 
 
58
 
 
59
class _UnicodeFilename(Feature):
 
60
    """Does the filesystem support Unicode filenames?"""
 
61
 
 
62
    def _probe(self):
 
63
        try:
 
64
            os.stat(u'\u03b1')
 
65
        except UnicodeEncodeError:
 
66
            return False
 
67
        except (IOError, OSError):
 
68
            # The filesystem allows the Unicode filename but the file doesn't
 
69
            # exist.
 
70
            return True
 
71
        else:
 
72
            # The filesystem allows the Unicode filename and the file exists,
 
73
            # for some reason.
 
74
            return True
 
75
 
 
76
UnicodeFilename = _UnicodeFilename()
 
77
 
 
78
 
 
79
class TestUnicodeFilename(TestCase):
 
80
 
 
81
    def test_probe_passes(self):
 
82
        """UnicodeFilename._probe passes."""
 
83
        # We can't test much more than that because the behaviour depends
 
84
        # on the platform.
 
85
        UnicodeFilename._probe()
 
86
        
44
87
 
45
88
def udiff_lines(old, new, allow_binary=False):
46
89
    output = StringIO()
47
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
90
    internal_diff('old', old, 'new', new, output, allow_binary)
48
91
    output.seek(0, 0)
49
92
    return output.readlines()
50
93
 
54
97
        # StringIO has no fileno, so it tests a different codepath
55
98
        output = StringIO()
56
99
    else:
57
 
        output = tempfile.TemporaryFile()
 
100
        output = TemporaryFile()
58
101
    try:
59
 
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
60
 
    except errors.NoDiff:
61
 
        raise tests.TestSkipped('external "diff" not present to test')
 
102
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
103
    except NoDiff:
 
104
        raise TestSkipped('external "diff" not present to test')
62
105
    output.seek(0, 0)
63
106
    lines = output.readlines()
64
107
    output.close()
65
108
    return lines
66
109
 
67
110
 
68
 
class TestDiffOptions(tests.TestCase):
69
 
 
70
 
    def test_unified_added(self):
71
 
        """Check for default style '-u' only if no other style specified
72
 
        in 'diff-options'.
73
 
        """
74
 
        # Verify that style defaults to unified, id est '-u' appended
75
 
        # to option list, in the absence of an alternative style.
76
 
        self.assertEqual(['-a', '-u'], diff.default_style_unified(['-a']))
77
 
 
78
 
 
79
 
class TestDiffOptionsScenarios(tests.TestCase):
80
 
 
81
 
    scenarios = [(s, dict(style=s)) for s in diff.style_option_list]
82
 
    style = None # Set by load_tests_apply_scenarios from scenarios
83
 
 
84
 
    def test_unified_not_added(self):
85
 
        # Verify that for all valid style options, '-u' is not
86
 
        # appended to option list.
87
 
        ret_opts = diff.default_style_unified(diff_opts=["%s" % (self.style,)])
88
 
        self.assertEqual(["%s" % (self.style,)], ret_opts)
89
 
 
90
 
 
91
 
class TestDiff(tests.TestCase):
 
111
class TestDiff(TestCase):
92
112
 
93
113
    def test_add_nl(self):
94
114
        """diff generates a valid diff for patches that add a newline"""
95
115
        lines = udiff_lines(['boo'], ['boo\n'])
96
116
        self.check_patch(lines)
97
 
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
 
117
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
98
118
            ## "expected no-nl, got %r" % lines[4]
99
119
 
100
120
    def test_add_nl_2(self):
103
123
        """
104
124
        lines = udiff_lines(['boo'], ['goo\n'])
105
125
        self.check_patch(lines)
106
 
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
 
126
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
107
127
            ## "expected no-nl, got %r" % lines[4]
108
128
 
109
129
    def test_remove_nl(self):
112
132
        """
113
133
        lines = udiff_lines(['boo\n'], ['boo'])
114
134
        self.check_patch(lines)
115
 
        self.assertEqual(lines[5], '\\ No newline at end of file\n')
 
135
        self.assertEquals(lines[5], '\\ No newline at end of file\n')
116
136
            ## "expected no-nl, got %r" % lines[5]
117
137
 
118
138
    def check_patch(self, lines):
119
 
        self.assertTrue(len(lines) > 1)
 
139
        self.assert_(len(lines) > 1)
120
140
            ## "Not enough lines for a file header for patch:\n%s" % "".join(lines)
121
 
        self.assertTrue(lines[0].startswith ('---'))
 
141
        self.assert_(lines[0].startswith ('---'))
122
142
            ## 'No orig line for patch:\n%s' % "".join(lines)
123
 
        self.assertTrue(lines[1].startswith ('+++'))
 
143
        self.assert_(lines[1].startswith ('+++'))
124
144
            ## 'No mod line for patch:\n%s' % "".join(lines)
125
 
        self.assertTrue(len(lines) > 2)
 
145
        self.assert_(len(lines) > 2)
126
146
            ## "No hunks for patch:\n%s" % "".join(lines)
127
 
        self.assertTrue(lines[2].startswith('@@'))
 
147
        self.assert_(lines[2].startswith('@@'))
128
148
            ## "No hunk header for patch:\n%s" % "".join(lines)
129
 
        self.assertTrue('@@' in lines[2][2:])
 
149
        self.assert_('@@' in lines[2][2:])
130
150
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
131
151
 
132
152
    def test_binary_lines(self):
133
 
        empty = []
134
 
        uni_lines = [1023 * 'a' + '\x00']
135
 
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
136
 
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
137
 
        udiff_lines(uni_lines , empty, allow_binary=True)
138
 
        udiff_lines(empty, uni_lines, allow_binary=True)
 
153
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
154
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
155
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
156
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
139
157
 
140
158
    def test_external_diff(self):
141
159
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
151
169
        self.check_patch(lines)
152
170
 
153
171
    def test_external_diff_binary_lang_c(self):
 
172
        old_env = {}
154
173
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
155
 
            self.overrideEnv(lang, 'C')
156
 
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
157
 
        # Older versions of diffutils say "Binary files", newer
158
 
        # versions just say "Files".
159
 
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
160
 
        self.assertEqual(lines[1:], ['\n'])
 
174
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
175
        try:
 
176
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
177
            # Older versions of diffutils say "Binary files", newer
 
178
            # versions just say "Files".
 
179
            self.assertContainsRe(lines[0],
 
180
                                  '(Binary f|F)iles old and new differ\n')
 
181
            self.assertEquals(lines[1:], ['\n'])
 
182
        finally:
 
183
            for lang, old_val in old_env.iteritems():
 
184
                osutils.set_or_unset_env(lang, old_val)
161
185
 
162
186
    def test_no_external_diff(self):
163
187
        """Check that NoDiff is raised when diff is not available"""
164
 
        # Make sure no 'diff' command is available
165
 
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
166
 
        self.overrideEnv('PATH', '')
167
 
        self.assertRaises(errors.NoDiff, diff.external_diff,
168
 
                          'old', ['boo\n'], 'new', ['goo\n'],
169
 
                          StringIO(), diff_opts=['-u'])
170
 
 
 
188
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
189
        orig_path = os.environ['PATH']
 
190
        try:
 
191
            os.environ['PATH'] = ''
 
192
            self.assertRaises(NoDiff, external_diff,
 
193
                              'old', ['boo\n'], 'new', ['goo\n'],
 
194
                              StringIO(), diff_opts=['-u'])
 
195
        finally:
 
196
            os.environ['PATH'] = orig_path
 
197
        
171
198
    def test_internal_diff_default(self):
172
199
        # Default internal diff encoding is utf8
173
200
        output = StringIO()
174
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
175
 
                           u'new_\xe5', ['new_text\n'], output)
 
201
        internal_diff(u'old_\xb5', ['old_text\n'],
 
202
                    u'new_\xe5', ['new_text\n'], output)
176
203
        lines = output.getvalue().splitlines(True)
177
204
        self.check_patch(lines)
178
 
        self.assertEqual(['--- old_\xc2\xb5\n',
 
205
        self.assertEquals(['--- old_\xc2\xb5\n',
179
206
                           '+++ new_\xc3\xa5\n',
180
207
                           '@@ -1,1 +1,1 @@\n',
181
208
                           '-old_text\n',
186
213
 
187
214
    def test_internal_diff_utf8(self):
188
215
        output = StringIO()
189
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
190
 
                           u'new_\xe5', ['new_text\n'], output,
191
 
                           path_encoding='utf8')
 
216
        internal_diff(u'old_\xb5', ['old_text\n'],
 
217
                    u'new_\xe5', ['new_text\n'], output,
 
218
                    path_encoding='utf8')
192
219
        lines = output.getvalue().splitlines(True)
193
220
        self.check_patch(lines)
194
 
        self.assertEqual(['--- old_\xc2\xb5\n',
 
221
        self.assertEquals(['--- old_\xc2\xb5\n',
195
222
                           '+++ new_\xc3\xa5\n',
196
223
                           '@@ -1,1 +1,1 @@\n',
197
224
                           '-old_text\n',
202
229
 
203
230
    def test_internal_diff_iso_8859_1(self):
204
231
        output = StringIO()
205
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
206
 
                           u'new_\xe5', ['new_text\n'], output,
207
 
                           path_encoding='iso-8859-1')
 
232
        internal_diff(u'old_\xb5', ['old_text\n'],
 
233
                    u'new_\xe5', ['new_text\n'], output,
 
234
                    path_encoding='iso-8859-1')
208
235
        lines = output.getvalue().splitlines(True)
209
236
        self.check_patch(lines)
210
 
        self.assertEqual(['--- old_\xb5\n',
 
237
        self.assertEquals(['--- old_\xb5\n',
211
238
                           '+++ new_\xe5\n',
212
239
                           '@@ -1,1 +1,1 @@\n',
213
240
                           '-old_text\n',
218
245
 
219
246
    def test_internal_diff_no_content(self):
220
247
        output = StringIO()
221
 
        diff.internal_diff(u'old', [], u'new', [], output)
 
248
        internal_diff(u'old', [], u'new', [], output)
222
249
        self.assertEqual('', output.getvalue())
223
250
 
224
251
    def test_internal_diff_no_changes(self):
225
252
        output = StringIO()
226
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
227
 
                           u'new', ['text\n', 'contents\n'],
228
 
                           output)
 
253
        internal_diff(u'old', ['text\n', 'contents\n'],
 
254
                      u'new', ['text\n', 'contents\n'],
 
255
                      output)
229
256
        self.assertEqual('', output.getvalue())
230
257
 
231
258
    def test_internal_diff_returns_bytes(self):
232
259
        import StringIO
233
260
        output = StringIO.StringIO()
234
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
235
 
                            u'new_\xe5', ['new_text\n'], output)
236
 
        self.assertIsInstance(output.getvalue(), str,
 
261
        internal_diff(u'old_\xb5', ['old_text\n'],
 
262
                    u'new_\xe5', ['new_text\n'], output)
 
263
        self.failUnless(isinstance(output.getvalue(), str),
237
264
            'internal_diff should return bytestrings')
238
265
 
239
 
    def test_internal_diff_default_context(self):
240
 
        output = StringIO()
241
 
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
242
 
                           'same_text\n','same_text\n','old_text\n'],
243
 
                           'new', ['same_text\n','same_text\n','same_text\n',
244
 
                           'same_text\n','same_text\n','new_text\n'], output)
245
 
        lines = output.getvalue().splitlines(True)
246
 
        self.check_patch(lines)
247
 
        self.assertEqual(['--- old\n',
248
 
                           '+++ new\n',
249
 
                           '@@ -3,4 +3,4 @@\n',
250
 
                           ' same_text\n',
251
 
                           ' same_text\n',
252
 
                           ' same_text\n',
253
 
                           '-old_text\n',
254
 
                           '+new_text\n',
255
 
                           '\n',
256
 
                          ]
257
 
                          , lines)
258
 
 
259
 
    def test_internal_diff_no_context(self):
260
 
        output = StringIO()
261
 
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
262
 
                           'same_text\n','same_text\n','old_text\n'],
263
 
                           'new', ['same_text\n','same_text\n','same_text\n',
264
 
                           'same_text\n','same_text\n','new_text\n'], output,
265
 
                           context_lines=0)
266
 
        lines = output.getvalue().splitlines(True)
267
 
        self.check_patch(lines)
268
 
        self.assertEqual(['--- old\n',
269
 
                           '+++ new\n',
270
 
                           '@@ -6,1 +6,1 @@\n',
271
 
                           '-old_text\n',
272
 
                           '+new_text\n',
273
 
                           '\n',
274
 
                          ]
275
 
                          , lines)
276
 
 
277
 
    def test_internal_diff_more_context(self):
278
 
        output = StringIO()
279
 
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
280
 
                           'same_text\n','same_text\n','old_text\n'],
281
 
                           'new', ['same_text\n','same_text\n','same_text\n',
282
 
                           'same_text\n','same_text\n','new_text\n'], output,
283
 
                           context_lines=4)
284
 
        lines = output.getvalue().splitlines(True)
285
 
        self.check_patch(lines)
286
 
        self.assertEqual(['--- old\n',
287
 
                           '+++ new\n',
288
 
                           '@@ -2,5 +2,5 @@\n',
289
 
                           ' same_text\n',
290
 
                           ' same_text\n',
291
 
                           ' same_text\n',
292
 
                           ' same_text\n',
293
 
                           '-old_text\n',
294
 
                           '+new_text\n',
295
 
                           '\n',
296
 
                          ]
297
 
                          , lines)
298
 
 
299
 
 
300
 
 
301
 
 
302
 
 
303
 
class TestDiffFiles(tests.TestCaseInTempDir):
 
266
 
 
267
class TestDiffFiles(TestCaseInTempDir):
304
268
 
305
269
    def test_external_diff_binary(self):
306
270
        """The output when using external diff should use diff's i18n error"""
308
272
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
309
273
 
310
274
        cmd = ['diff', '-u', '--binary', 'old', 'new']
311
 
        with open('old', 'wb') as f: f.write('\x00foobar\n')
312
 
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
 
275
        open('old', 'wb').write('\x00foobar\n')
 
276
        open('new', 'wb').write('foo\x00bar\n')
313
277
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
314
278
                                     stdin=subprocess.PIPE)
315
279
        out, err = pipe.communicate()
319
283
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
320
284
 
321
285
 
322
 
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
323
 
    output = StringIO()
324
 
    if working_tree is not None:
325
 
        extra_trees = (working_tree,)
326
 
    else:
327
 
        extra_trees = ()
328
 
    diff.show_diff_trees(tree1, tree2, output,
329
 
        specific_files=specific_files,
330
 
        extra_trees=extra_trees, old_label='old/',
331
 
        new_label='new/')
332
 
    return output.getvalue()
333
 
 
334
 
 
335
 
class TestDiffDates(tests.TestCaseWithTransport):
 
286
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
287
    """Has a helper for running show_diff_trees"""
 
288
 
 
289
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
290
        output = StringIO()
 
291
        if working_tree is not None:
 
292
            extra_trees = (working_tree,)
 
293
        else:
 
294
            extra_trees = ()
 
295
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
296
                        extra_trees=extra_trees, old_label='old/',
 
297
                        new_label='new/')
 
298
        return output.getvalue()
 
299
 
 
300
 
 
301
class TestDiffDates(TestShowDiffTreesHelper):
336
302
 
337
303
    def setUp(self):
338
304
        super(TestDiffDates, self).setUp()
373
339
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
374
340
 
375
341
    def test_diff_rev_tree_working_tree(self):
376
 
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
 
342
        output = self.get_diff(self.wt.basis_tree(), self.wt)
377
343
        # note that the date for old/file1 is from rev 2 rather than from
378
344
        # the basis revision (rev 4)
379
345
        self.assertEqualDiff(output, '''\
389
355
    def test_diff_rev_tree_rev_tree(self):
390
356
        tree1 = self.b.repository.revision_tree('rev-2')
391
357
        tree2 = self.b.repository.revision_tree('rev-3')
392
 
        output = get_diff_as_string(tree1, tree2)
 
358
        output = self.get_diff(tree1, tree2)
393
359
        self.assertEqualDiff(output, '''\
394
360
=== modified file 'file2'
395
361
--- old/file2\t2006-04-01 00:00:00 +0000
399
365
+file2 contents at rev 3
400
366
 
401
367
''')
402
 
 
 
368
        
403
369
    def test_diff_add_files(self):
404
 
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
 
370
        tree1 = self.b.repository.revision_tree(None)
405
371
        tree2 = self.b.repository.revision_tree('rev-1')
406
 
        output = get_diff_as_string(tree1, tree2)
 
372
        output = self.get_diff(tree1, tree2)
407
373
        # the files have the epoch time stamp for the tree in which
408
374
        # they don't exist.
409
375
        self.assertEqualDiff(output, '''\
424
390
    def test_diff_remove_files(self):
425
391
        tree1 = self.b.repository.revision_tree('rev-3')
426
392
        tree2 = self.b.repository.revision_tree('rev-4')
427
 
        output = get_diff_as_string(tree1, tree2)
 
393
        output = self.get_diff(tree1, tree2)
428
394
        # the file has the epoch time stamp for the tree in which
429
395
        # it doesn't exist.
430
396
        self.assertEqualDiff(output, '''\
441
407
        self.wt.rename_one('file1', 'file1b')
442
408
        old_tree = self.b.repository.revision_tree('rev-1')
443
409
        new_tree = self.b.repository.revision_tree('rev-4')
444
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
 
410
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
445
411
                            working_tree=self.wt)
446
412
        self.assertContainsRe(out, 'file1\t')
447
413
 
453
419
        self.wt.rename_one('file1', 'dir1/file1')
454
420
        old_tree = self.b.repository.revision_tree('rev-1')
455
421
        new_tree = self.b.repository.revision_tree('rev-4')
456
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
 
422
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
457
423
                            working_tree=self.wt)
458
424
        self.assertContainsRe(out, 'file1\t')
459
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
 
425
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
460
426
                            working_tree=self.wt)
461
427
        self.assertNotContainsRe(out, 'file1\t')
462
428
 
463
429
 
464
 
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
430
 
 
431
class TestShowDiffTrees(TestShowDiffTreesHelper):
465
432
    """Direct tests for show_diff_trees"""
466
433
 
467
434
    def test_modified_file(self):
472
439
        tree.commit('one', rev_id='rev-1')
473
440
 
474
441
        self.build_tree_contents([('tree/file', 'new contents\n')])
475
 
        d = get_diff_as_string(tree.basis_tree(), tree)
476
 
        self.assertContainsRe(d, "=== modified file 'file'\n")
477
 
        self.assertContainsRe(d, '--- old/file\t')
478
 
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
479
 
        self.assertContainsRe(d, '-contents\n'
480
 
                                 '\\+new contents\n')
 
442
        diff = self.get_diff(tree.basis_tree(), tree)
 
443
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
444
        self.assertContainsRe(diff, '--- old/file\t')
 
445
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
446
        self.assertContainsRe(diff, '-contents\n'
 
447
                                    '\\+new contents\n')
481
448
 
482
449
    def test_modified_file_in_renamed_dir(self):
483
450
        """Test when a file is modified in a renamed directory."""
489
456
 
490
457
        tree.rename_one('dir', 'other')
491
458
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
492
 
        d = get_diff_as_string(tree.basis_tree(), tree)
493
 
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
494
 
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
459
        diff = self.get_diff(tree.basis_tree(), tree)
 
460
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
461
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
495
462
        # XXX: This is technically incorrect, because it used to be at another
496
463
        # location. What to do?
497
 
        self.assertContainsRe(d, '--- old/dir/file\t')
498
 
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
499
 
        self.assertContainsRe(d, '-contents\n'
500
 
                                 '\\+new contents\n')
 
464
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
465
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
466
        self.assertContainsRe(diff, '-contents\n'
 
467
                                    '\\+new contents\n')
501
468
 
502
469
    def test_renamed_directory(self):
503
470
        """Test when only a directory is only renamed."""
508
475
        tree.commit('one', rev_id='rev-1')
509
476
 
510
477
        tree.rename_one('dir', 'newdir')
511
 
        d = get_diff_as_string(tree.basis_tree(), tree)
 
478
        diff = self.get_diff(tree.basis_tree(), tree)
512
479
        # Renaming a directory should be a single "you renamed this dir" even
513
480
        # when there are files inside.
514
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
481
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
515
482
 
516
483
    def test_renamed_file(self):
517
484
        """Test when a file is only renamed."""
521
488
        tree.commit('one', rev_id='rev-1')
522
489
 
523
490
        tree.rename_one('file', 'newname')
524
 
        d = get_diff_as_string(tree.basis_tree(), tree)
525
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
491
        diff = self.get_diff(tree.basis_tree(), tree)
 
492
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
526
493
        # We shouldn't have a --- or +++ line, because there is no content
527
494
        # change
528
 
        self.assertNotContainsRe(d, '---')
 
495
        self.assertNotContainsRe(diff, '---')
529
496
 
530
497
    def test_renamed_and_modified_file(self):
531
498
        """Test when a file is only renamed."""
536
503
 
537
504
        tree.rename_one('file', 'newname')
538
505
        self.build_tree_contents([('tree/newname', 'new contents\n')])
539
 
        d = get_diff_as_string(tree.basis_tree(), tree)
540
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
541
 
        self.assertContainsRe(d, '--- old/file\t')
542
 
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
543
 
        self.assertContainsRe(d, '-contents\n'
544
 
                                 '\\+new contents\n')
 
506
        diff = self.get_diff(tree.basis_tree(), tree)
 
507
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
508
        self.assertContainsRe(diff, '--- old/file\t')
 
509
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
510
        self.assertContainsRe(diff, '-contents\n'
 
511
                                    '\\+new contents\n')
545
512
 
546
513
 
547
514
    def test_internal_diff_exec_property(self):
566
533
        tree.rename_one('c', 'new-c')
567
534
        tree.rename_one('d', 'new-d')
568
535
 
569
 
        d = get_diff_as_string(tree.basis_tree(), tree)
570
 
 
571
 
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
572
 
                                  ".*\+x to -x.*\)")
573
 
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
574
 
                                  ".*-x to \+x.*\)")
575
 
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
576
 
                                  ".*\+x to -x.*\)")
577
 
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
578
 
                                  ".*-x to \+x.*\)")
579
 
        self.assertNotContainsRe(d, r"file 'e'")
580
 
        self.assertNotContainsRe(d, r"file 'f'")
 
536
        diff = self.get_diff(tree.basis_tree(), tree)
 
537
 
 
538
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
 
539
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
 
540
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
 
541
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
 
542
        self.assertNotContainsRe(diff, r"file 'e'")
 
543
        self.assertNotContainsRe(diff, r"file 'f'")
 
544
 
581
545
 
582
546
    def test_binary_unicode_filenames(self):
583
547
        """Test that contents of files are *not* encoded in UTF-8 when there
584
548
        is a binary file in the diff.
585
549
        """
586
550
        # See https://bugs.launchpad.net/bugs/110092.
587
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
551
        self.requireFeature(UnicodeFilename)
588
552
 
589
553
        # This bug isn't triggered with cStringIO.
590
554
        from StringIO import StringIO
598
562
        tree.add([alpha], ['file-id'])
599
563
        tree.add([omega], ['file-id-2'])
600
564
        diff_content = StringIO()
601
 
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
602
 
        d = diff_content.getvalue()
603
 
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
604
 
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
605
 
                              % (alpha_utf8, alpha_utf8))
606
 
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
607
 
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
608
 
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
 
565
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
566
        diff = diff_content.getvalue()
 
567
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
568
        self.assertContainsRe(
 
569
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
570
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
571
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
572
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
609
573
 
610
574
    def test_unicode_filename(self):
611
575
        """Test when the filename are unicode."""
612
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
576
        self.requireFeature(UnicodeFilename)
613
577
 
614
578
        alpha, omega = u'\u03b1', u'\u03c9'
615
579
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
630
594
        tree.add(['add_'+alpha], ['file-id'])
631
595
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
632
596
 
633
 
        d = get_diff_as_string(tree.basis_tree(), tree)
634
 
        self.assertContainsRe(d,
 
597
        diff = self.get_diff(tree.basis_tree(), tree)
 
598
        self.assertContainsRe(diff,
635
599
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
636
 
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
637
 
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
638
 
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
639
 
 
640
 
    def test_unicode_filename_path_encoding(self):
641
 
        """Test for bug #382699: unicode filenames on Windows should be shown
642
 
        in user encoding.
643
 
        """
644
 
        self.requireFeature(features.UnicodeFilenameFeature)
645
 
        # The word 'test' in Russian
646
 
        _russian_test = u'\u0422\u0435\u0441\u0442'
647
 
        directory = _russian_test + u'/'
648
 
        test_txt = _russian_test + u'.txt'
649
 
        u1234 = u'\u1234.txt'
650
 
 
651
 
        tree = self.make_branch_and_tree('.')
652
 
        self.build_tree_contents([
653
 
            (test_txt, 'foo\n'),
654
 
            (u1234, 'foo\n'),
655
 
            (directory, None),
656
 
            ])
657
 
        tree.add([test_txt, u1234, directory])
658
 
 
659
 
        sio = StringIO()
660
 
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
661
 
            path_encoding='cp1251')
662
 
 
663
 
        output = subst_dates(sio.getvalue())
664
 
        shouldbe = ('''\
665
 
=== added directory '%(directory)s'
666
 
=== added file '%(test_txt)s'
667
 
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
668
 
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
669
 
@@ -0,0 +1,1 @@
670
 
+foo
671
 
 
672
 
=== added file '?.txt'
673
 
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
674
 
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
675
 
@@ -0,0 +1,1 @@
676
 
+foo
677
 
 
678
 
''' % {'directory': _russian_test.encode('cp1251'),
679
 
       'test_txt': test_txt.encode('cp1251'),
680
 
      })
681
 
        self.assertEqualDiff(output, shouldbe)
682
 
 
683
 
 
684
 
class DiffWasIs(diff.DiffPath):
 
600
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
601
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
602
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
603
 
 
604
 
 
605
class DiffWasIs(DiffPath):
685
606
 
686
607
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
687
608
        self.to_file.write('was: ')
691
612
        pass
692
613
 
693
614
 
694
 
class TestDiffTree(tests.TestCaseWithTransport):
 
615
class TestDiffTree(TestCaseWithTransport):
695
616
 
696
617
    def setUp(self):
697
 
        super(TestDiffTree, self).setUp()
 
618
        TestCaseWithTransport.setUp(self)
698
619
        self.old_tree = self.make_branch_and_tree('old-tree')
699
620
        self.old_tree.lock_write()
700
621
        self.addCleanup(self.old_tree.unlock)
701
622
        self.new_tree = self.make_branch_and_tree('new-tree')
702
623
        self.new_tree.lock_write()
703
624
        self.addCleanup(self.new_tree.unlock)
704
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
625
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
705
626
 
706
627
    def test_diff_text(self):
707
628
        self.build_tree_contents([('old-tree/olddir/',),
712
633
                                  ('new-tree/newdir/newfile', 'new\n')])
713
634
        self.new_tree.add('newdir')
714
635
        self.new_tree.add('newdir/newfile', 'file-id')
715
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
636
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
716
637
        differ.diff_text('file-id', None, 'old label', 'new label')
717
638
        self.assertEqual(
718
639
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
747
668
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
748
669
 
749
670
    def test_diff_symlink(self):
750
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
671
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
751
672
        differ.diff_symlink('old target', None)
752
673
        self.assertEqual("=== target was 'old target'\n",
753
674
                         differ.to_file.getvalue())
754
675
 
755
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
676
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
756
677
        differ.diff_symlink(None, 'new target')
757
678
        self.assertEqual("=== target is 'new target'\n",
758
679
                         differ.to_file.getvalue())
759
680
 
760
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
681
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
761
682
        differ.diff_symlink('old target', 'new target')
762
683
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
763
684
                         differ.to_file.getvalue())
778
699
             ' \@\@\n-old\n\+new\n\n')
779
700
 
780
701
    def test_diff_kind_change(self):
781
 
        self.requireFeature(features.SymlinkFeature)
 
702
        self.requireFeature(tests.SymlinkFeature)
782
703
        self.build_tree_contents([('old-tree/olddir/',),
783
704
                                  ('old-tree/olddir/oldfile', 'old\n')])
784
705
        self.old_tree.add('olddir')
793
714
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
794
715
             ' \@\@\n-old\n\n')
795
716
        self.assertContainsRe(self.differ.to_file.getvalue(),
796
 
                              "=== target is u'new'\n")
 
717
                              "=== target is 'new'\n")
797
718
 
798
719
    def test_diff_directory(self):
799
720
        self.build_tree(['new-tree/new-dir/'])
813
734
 
814
735
    def test_register_diff(self):
815
736
        self.create_old_new()
816
 
        old_diff_factories = diff.DiffTree.diff_factories
817
 
        diff.DiffTree.diff_factories=old_diff_factories[:]
818
 
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
737
        old_diff_factories = DiffTree.diff_factories
 
738
        DiffTree.diff_factories=old_diff_factories[:]
 
739
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
819
740
        try:
820
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
741
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
821
742
        finally:
822
 
            diff.DiffTree.diff_factories = old_diff_factories
 
743
            DiffTree.diff_factories = old_diff_factories
823
744
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
824
745
        self.assertNotContainsRe(
825
746
            differ.to_file.getvalue(),
830
751
 
831
752
    def test_extra_factories(self):
832
753
        self.create_old_new()
833
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
834
 
                               extra_factories=[DiffWasIs.from_diff_tree])
 
754
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
755
                            extra_factories=[DiffWasIs.from_diff_tree])
835
756
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
836
757
        self.assertNotContainsRe(
837
758
            differ.to_file.getvalue(),
850
771
            '.*a-file(.|\n)*b-file')
851
772
 
852
773
 
853
 
class TestPatienceDiffLib(tests.TestCase):
 
774
class TestPatienceDiffLib(TestCase):
854
775
 
855
776
    def setUp(self):
856
777
        super(TestPatienceDiffLib, self).setUp()
857
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
858
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
778
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
779
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
859
780
        self._PatienceSequenceMatcher = \
860
 
            _patiencediff_py.PatienceSequenceMatcher_py
861
 
 
862
 
    def test_diff_unicode_string(self):
863
 
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
864
 
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
865
 
        sm = self._PatienceSequenceMatcher(None, a, b)
866
 
        mb = sm.get_matching_blocks()
867
 
        self.assertEqual(35, len(mb))
 
781
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
868
782
 
869
783
    def test_unique_lcs(self):
870
784
        unique_lcs = self._unique_lcs
871
 
        self.assertEqual(unique_lcs('', ''), [])
872
 
        self.assertEqual(unique_lcs('', 'a'), [])
873
 
        self.assertEqual(unique_lcs('a', ''), [])
874
 
        self.assertEqual(unique_lcs('a', 'a'), [(0,0)])
875
 
        self.assertEqual(unique_lcs('a', 'b'), [])
876
 
        self.assertEqual(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
877
 
        self.assertEqual(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
878
 
        self.assertEqual(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
879
 
        self.assertEqual(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
785
        self.assertEquals(unique_lcs('', ''), [])
 
786
        self.assertEquals(unique_lcs('', 'a'), [])
 
787
        self.assertEquals(unique_lcs('a', ''), [])
 
788
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
 
789
        self.assertEquals(unique_lcs('a', 'b'), [])
 
790
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
 
791
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
 
792
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
 
793
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
880
794
                                                         (3,3), (4,4)])
881
 
        self.assertEqual(unique_lcs('acbac', 'abc'), [(2,1)])
 
795
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
882
796
 
883
797
    def test_recurse_matches(self):
884
798
        def test_one(a, b, matches):
885
799
            test_matches = []
886
800
            self._recurse_matches(
887
801
                a, b, 0, 0, len(a), len(b), test_matches, 10)
888
 
            self.assertEqual(test_matches, matches)
 
802
            self.assertEquals(test_matches, matches)
889
803
 
890
804
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
891
805
                 [(0, 0), (2, 2), (4, 4)])
897
811
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
898
812
                                          (4, 6), (5, 7), (6, 8)])
899
813
 
900
 
        # recurse_matches doesn't match non-unique
 
814
        # recurse_matches doesn't match non-unique 
901
815
        # lines surrounded by bogus text.
902
816
        # The update has been done in patiencediff.SequenceMatcher instead
903
817
 
996
910
    def test_opcodes(self):
997
911
        def chk_ops(a, b, expected_codes):
998
912
            s = self._PatienceSequenceMatcher(None, a, b)
999
 
            self.assertEqual(expected_codes, s.get_opcodes())
 
913
            self.assertEquals(expected_codes, s.get_opcodes())
1000
914
 
1001
915
        chk_ops('', '', [])
1002
916
        chk_ops([], [], [])
1040
954
                 ('delete', 1,2, 1,1),
1041
955
                 ('equal',  2,3, 1,2),
1042
956
                ])
1043
 
        chk_ops('aBccDe', 'abccde',
 
957
        chk_ops('aBccDe', 'abccde', 
1044
958
                [('equal',   0,1, 0,1),
1045
959
                 ('replace', 1,5, 1,5),
1046
960
                 ('equal',   5,6, 5,6),
1047
961
                ])
1048
 
        chk_ops('aBcDec', 'abcdec',
 
962
        chk_ops('aBcDec', 'abcdec', 
1049
963
                [('equal',   0,1, 0,1),
1050
964
                 ('replace', 1,2, 1,2),
1051
965
                 ('equal',   2,3, 2,3),
1052
966
                 ('replace', 3,4, 3,4),
1053
967
                 ('equal',   4,6, 4,6),
1054
968
                ])
1055
 
        chk_ops('aBcdEcdFg', 'abcdecdfg',
 
969
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
1056
970
                [('equal',   0,1, 0,1),
1057
971
                 ('replace', 1,8, 1,8),
1058
972
                 ('equal',   8,9, 8,9)
1059
973
                ])
1060
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
 
974
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
1061
975
                [('equal',   0,1, 0,1),
1062
976
                 ('replace', 1,2, 1,2),
1063
977
                 ('equal',   2,4, 2,4),
1072
986
    def test_grouped_opcodes(self):
1073
987
        def chk_ops(a, b, expected_codes, n=3):
1074
988
            s = self._PatienceSequenceMatcher(None, a, b)
1075
 
            self.assertEqual(expected_codes, list(s.get_grouped_opcodes(n)))
 
989
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
1076
990
 
1077
991
        chk_ops('', '', [])
1078
992
        chk_ops([], [], [])
1123
1037
    """
1124
1038
    gnxrf_netf = ['svyr*']
1125
1039
    gnxrf_bcgvbaf = ['ab-erphefr']
1126
 
 
 
1040
  
1127
1041
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1128
1042
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1129
1043
        vs vf_dhvrg():
1137
1051
'''.splitlines(True), '''\
1138
1052
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1139
1053
 
1140
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
 
1054
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
1141
1055
    nqq gurz.
1142
1056
    """
1143
1057
    gnxrf_netf = ['svyr*']
1170
1084
                 'how are you today?\n']
1171
1085
        txt_b = ['hello there\n',
1172
1086
                 'how are you today?\n']
1173
 
        unified_diff = patiencediff.unified_diff
 
1087
        unified_diff = bzrlib.patiencediff.unified_diff
1174
1088
        psm = self._PatienceSequenceMatcher
1175
 
        self.assertEqual(['--- \n',
1176
 
                           '+++ \n',
 
1089
        self.assertEquals([ '---  \n',
 
1090
                           '+++  \n',
1177
1091
                           '@@ -1,3 +1,2 @@\n',
1178
1092
                           ' hello there\n',
1179
1093
                           '-world\n',
1184
1098
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1185
1099
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1186
1100
        # This is the result with LongestCommonSubstring matching
1187
 
        self.assertEqual(['--- \n',
1188
 
                           '+++ \n',
 
1101
        self.assertEquals(['---  \n',
 
1102
                           '+++  \n',
1189
1103
                           '@@ -1,6 +1,11 @@\n',
1190
1104
                           ' a\n',
1191
1105
                           ' b\n',
1200
1114
                           ' f\n']
1201
1115
                          , list(unified_diff(txt_a, txt_b)))
1202
1116
        # And the patience diff
1203
 
        self.assertEqual(['--- \n',
1204
 
                           '+++ \n',
 
1117
        self.assertEquals(['---  \n',
 
1118
                           '+++  \n',
1205
1119
                           '@@ -4,6 +4,11 @@\n',
1206
1120
                           ' d\n',
1207
1121
                           ' e\n',
1218
1132
                          , list(unified_diff(txt_a, txt_b,
1219
1133
                                 sequencematcher=psm)))
1220
1134
 
1221
 
    def test_patience_unified_diff_with_dates(self):
1222
 
        txt_a = ['hello there\n',
1223
 
                 'world\n',
1224
 
                 'how are you today?\n']
1225
 
        txt_b = ['hello there\n',
1226
 
                 'how are you today?\n']
1227
 
        unified_diff = patiencediff.unified_diff
1228
 
        psm = self._PatienceSequenceMatcher
1229
 
        self.assertEqual(['--- a\t2008-08-08\n',
1230
 
                           '+++ b\t2008-09-09\n',
1231
 
                           '@@ -1,3 +1,2 @@\n',
1232
 
                           ' hello there\n',
1233
 
                           '-world\n',
1234
 
                           ' how are you today?\n'
1235
 
                          ]
1236
 
                          , list(unified_diff(txt_a, txt_b,
1237
 
                                 fromfile='a', tofile='b',
1238
 
                                 fromfiledate='2008-08-08',
1239
 
                                 tofiledate='2008-09-09',
1240
 
                                 sequencematcher=psm)))
1241
 
 
1242
1135
 
1243
1136
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1244
1137
 
1245
 
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1138
    _test_needs_features = [CompiledPatienceDiffFeature]
1246
1139
 
1247
1140
    def setUp(self):
1248
1141
        super(TestPatienceDiffLib_c, self).setUp()
1249
 
        from bzrlib import _patiencediff_c
1250
 
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1251
 
        self._recurse_matches = _patiencediff_c.recurse_matches_c
 
1142
        import bzrlib._patiencediff_c
 
1143
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1144
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
1252
1145
        self._PatienceSequenceMatcher = \
1253
 
            _patiencediff_c.PatienceSequenceMatcher_c
 
1146
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1254
1147
 
1255
1148
    def test_unhashable(self):
1256
1149
        """We should get a proper exception here."""
1266
1159
                                         None, ['valid'], ['valid', []])
1267
1160
 
1268
1161
 
1269
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1162
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1270
1163
 
1271
1164
    def setUp(self):
1272
1165
        super(TestPatienceDiffLibFiles, self).setUp()
1273
1166
        self._PatienceSequenceMatcher = \
1274
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
1167
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1275
1168
 
1276
1169
    def test_patience_unified_diff_files(self):
1277
1170
        txt_a = ['hello there\n',
1279
1172
                 'how are you today?\n']
1280
1173
        txt_b = ['hello there\n',
1281
1174
                 'how are you today?\n']
1282
 
        with open('a1', 'wb') as f: f.writelines(txt_a)
1283
 
        with open('b1', 'wb') as f: f.writelines(txt_b)
 
1175
        open('a1', 'wb').writelines(txt_a)
 
1176
        open('b1', 'wb').writelines(txt_b)
1284
1177
 
1285
 
        unified_diff_files = patiencediff.unified_diff_files
 
1178
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1286
1179
        psm = self._PatienceSequenceMatcher
1287
 
        self.assertEqual(['--- a1\n',
1288
 
                           '+++ b1\n',
 
1180
        self.assertEquals(['--- a1 \n',
 
1181
                           '+++ b1 \n',
1289
1182
                           '@@ -1,3 +1,2 @@\n',
1290
1183
                           ' hello there\n',
1291
1184
                           '-world\n',
1296
1189
 
1297
1190
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1298
1191
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1299
 
        with open('a2', 'wb') as f: f.writelines(txt_a)
1300
 
        with open('b2', 'wb') as f: f.writelines(txt_b)
 
1192
        open('a2', 'wb').writelines(txt_a)
 
1193
        open('b2', 'wb').writelines(txt_b)
1301
1194
 
1302
1195
        # This is the result with LongestCommonSubstring matching
1303
 
        self.assertEqual(['--- a2\n',
1304
 
                           '+++ b2\n',
 
1196
        self.assertEquals(['--- a2 \n',
 
1197
                           '+++ b2 \n',
1305
1198
                           '@@ -1,6 +1,11 @@\n',
1306
1199
                           ' a\n',
1307
1200
                           ' b\n',
1317
1210
                          , list(unified_diff_files('a2', 'b2')))
1318
1211
 
1319
1212
        # And the patience diff
1320
 
        self.assertEqual(['--- a2\n',
1321
 
                          '+++ b2\n',
1322
 
                          '@@ -4,6 +4,11 @@\n',
1323
 
                          ' d\n',
1324
 
                          ' e\n',
1325
 
                          ' f\n',
1326
 
                          '+x\n',
1327
 
                          '+y\n',
1328
 
                          '+d\n',
1329
 
                          '+e\n',
1330
 
                          '+f\n',
1331
 
                          ' g\n',
1332
 
                          ' h\n',
1333
 
                          ' i\n'],
1334
 
                         list(unified_diff_files('a2', 'b2',
1335
 
                                                 sequencematcher=psm)))
 
1213
        self.assertEquals(['--- a2 \n',
 
1214
                           '+++ b2 \n',
 
1215
                           '@@ -4,6 +4,11 @@\n',
 
1216
                           ' d\n',
 
1217
                           ' e\n',
 
1218
                           ' f\n',
 
1219
                           '+x\n',
 
1220
                           '+y\n',
 
1221
                           '+d\n',
 
1222
                           '+e\n',
 
1223
                           '+f\n',
 
1224
                           ' g\n',
 
1225
                           ' h\n',
 
1226
                           ' i\n',
 
1227
                          ]
 
1228
                          , list(unified_diff_files('a2', 'b2',
 
1229
                                 sequencematcher=psm)))
1336
1230
 
1337
1231
 
1338
1232
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1339
1233
 
1340
 
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1234
    _test_needs_features = [CompiledPatienceDiffFeature]
1341
1235
 
1342
1236
    def setUp(self):
1343
1237
        super(TestPatienceDiffLibFiles_c, self).setUp()
1344
 
        from bzrlib import _patiencediff_c
 
1238
        import bzrlib._patiencediff_c
1345
1239
        self._PatienceSequenceMatcher = \
1346
 
            _patiencediff_c.PatienceSequenceMatcher_c
1347
 
 
1348
 
 
1349
 
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1240
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1241
 
 
1242
 
 
1243
class TestUsingCompiledIfAvailable(TestCase):
1350
1244
 
1351
1245
    def test_PatienceSequenceMatcher(self):
1352
 
        if features.compiled_patiencediff_feature.available():
 
1246
        if CompiledPatienceDiffFeature.available():
1353
1247
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1354
1248
            self.assertIs(PatienceSequenceMatcher_c,
1355
 
                          patiencediff.PatienceSequenceMatcher)
 
1249
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1356
1250
        else:
1357
1251
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1358
1252
            self.assertIs(PatienceSequenceMatcher_py,
1359
 
                          patiencediff.PatienceSequenceMatcher)
 
1253
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1360
1254
 
1361
1255
    def test_unique_lcs(self):
1362
 
        if features.compiled_patiencediff_feature.available():
 
1256
        if CompiledPatienceDiffFeature.available():
1363
1257
            from bzrlib._patiencediff_c import unique_lcs_c
1364
1258
            self.assertIs(unique_lcs_c,
1365
 
                          patiencediff.unique_lcs)
 
1259
                          bzrlib.patiencediff.unique_lcs)
1366
1260
        else:
1367
1261
            from bzrlib._patiencediff_py import unique_lcs_py
1368
1262
            self.assertIs(unique_lcs_py,
1369
 
                          patiencediff.unique_lcs)
 
1263
                          bzrlib.patiencediff.unique_lcs)
1370
1264
 
1371
1265
    def test_recurse_matches(self):
1372
 
        if features.compiled_patiencediff_feature.available():
 
1266
        if CompiledPatienceDiffFeature.available():
1373
1267
            from bzrlib._patiencediff_c import recurse_matches_c
1374
1268
            self.assertIs(recurse_matches_c,
1375
 
                          patiencediff.recurse_matches)
 
1269
                          bzrlib.patiencediff.recurse_matches)
1376
1270
        else:
1377
1271
            from bzrlib._patiencediff_py import recurse_matches_py
1378
1272
            self.assertIs(recurse_matches_py,
1379
 
                          patiencediff.recurse_matches)
1380
 
 
1381
 
 
1382
 
class TestDiffFromTool(tests.TestCaseWithTransport):
 
1273
                          bzrlib.patiencediff.recurse_matches)
 
1274
 
 
1275
 
 
1276
class TestDiffFromTool(TestCaseWithTransport):
1383
1277
 
1384
1278
    def test_from_string(self):
1385
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
 
1279
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
1386
1280
        self.addCleanup(diff_obj.finish)
1387
 
        self.assertEqual(['diff', '@old_path', '@new_path'],
 
1281
        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],
1388
1282
            diff_obj.command_template)
1389
1283
 
1390
1284
    def test_from_string_u5(self):
1391
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1392
 
                                                 None, None, None)
 
1285
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
1393
1286
        self.addCleanup(diff_obj.finish)
1394
 
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
 
1287
        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],
1395
1288
                         diff_obj.command_template)
1396
1289
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1397
1290
                         diff_obj._get_command('old-path', 'new-path'))
1398
1291
 
1399
 
    def test_from_string_path_with_backslashes(self):
1400
 
        self.requireFeature(features.backslashdir_feature)
1401
 
        tool = 'C:\\Tools\\Diff.exe'
1402
 
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1403
 
        self.addCleanup(diff_obj.finish)
1404
 
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1405
 
                         diff_obj.command_template)
1406
 
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
1407
 
                         diff_obj._get_command('old-path', 'new-path'))
1408
 
 
1409
1292
    def test_execute(self):
1410
1293
        output = StringIO()
1411
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1412
 
                                      'print "@old_path @new_path"'],
1413
 
                                     None, None, output)
 
1294
        diff_obj = DiffFromTool(['python', '-c',
 
1295
                                 'print "%(old_path)s %(new_path)s"'],
 
1296
                                None, None, output)
1414
1297
        self.addCleanup(diff_obj.finish)
1415
1298
        diff_obj._execute('old', 'new')
1416
1299
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1417
1300
 
1418
 
    def test_execute_missing(self):
1419
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1420
 
                                     None, None, None)
 
1301
    def test_excute_missing(self):
 
1302
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1303
                                None, None, None)
1421
1304
        self.addCleanup(diff_obj.finish)
1422
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1423
 
                              'old', 'new')
 
1305
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
 
1306
                              'new')
1424
1307
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1425
1308
                         ' on this machine', str(e))
1426
1309
 
1427
 
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1428
 
        self.requireFeature(features.AttribFeature)
1429
 
        output = StringIO()
1430
 
        tree = self.make_branch_and_tree('tree')
1431
 
        self.build_tree_contents([('tree/file', 'content')])
1432
 
        tree.add('file', 'file-id')
1433
 
        tree.commit('old tree')
1434
 
        tree.lock_read()
1435
 
        self.addCleanup(tree.unlock)
1436
 
        basis_tree = tree.basis_tree()
1437
 
        basis_tree.lock_read()
1438
 
        self.addCleanup(basis_tree.unlock)
1439
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1440
 
                                      'print "@old_path @new_path"'],
1441
 
                                     basis_tree, tree, output)
1442
 
        diff_obj._prepare_files('file-id', 'file', 'file')
1443
 
        # The old content should be readonly
1444
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1445
 
                                    r'R.*old\\file$')
1446
 
        # The new content should use the tree object, not a 'new' file anymore
1447
 
        self.assertEndsWith(tree.basedir, 'work/tree')
1448
 
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1449
 
 
1450
 
    def assertReadableByAttrib(self, cwd, relpath, regex):
1451
 
        proc = subprocess.Popen(['attrib', relpath],
1452
 
                                stdout=subprocess.PIPE,
1453
 
                                cwd=cwd)
1454
 
        (result, err) = proc.communicate()
1455
 
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1456
 
 
1457
1310
    def test_prepare_files(self):
1458
1311
        output = StringIO()
1459
1312
        tree = self.make_branch_and_tree('tree')
1460
1313
        self.build_tree_contents([('tree/oldname', 'oldcontent')])
1461
 
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1462
1314
        tree.add('oldname', 'file-id')
1463
 
        tree.add('oldname2', 'file2-id')
1464
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1465
 
        tree.commit('old tree', timestamp=315532800)
 
1315
        tree.commit('old tree', timestamp=0)
1466
1316
        tree.rename_one('oldname', 'newname')
1467
 
        tree.rename_one('oldname2', 'newname2')
1468
1317
        self.build_tree_contents([('tree/newname', 'newcontent')])
1469
 
        self.build_tree_contents([('tree/newname2', 'newcontent2')])
1470
1318
        old_tree = tree.basis_tree()
1471
1319
        old_tree.lock_read()
1472
1320
        self.addCleanup(old_tree.unlock)
1473
1321
        tree.lock_read()
1474
1322
        self.addCleanup(tree.unlock)
1475
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1476
 
                                      'print "@old_path @new_path"'],
1477
 
                                     old_tree, tree, output)
 
1323
        diff_obj = DiffFromTool(['python', '-c',
 
1324
                                 'print "%(old_path)s %(new_path)s"'],
 
1325
                                old_tree, tree, output)
1478
1326
        self.addCleanup(diff_obj.finish)
1479
1327
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1480
1328
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1481
1329
                                                     'newname')
1482
1330
        self.assertContainsRe(old_path, 'old/oldname$')
1483
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
1484
 
        self.assertContainsRe(new_path, 'tree/newname$')
 
1331
        self.assertEqual(0, os.stat(old_path).st_mtime)
 
1332
        self.assertContainsRe(new_path, 'new/newname$')
1485
1333
        self.assertFileEqual('oldcontent', old_path)
1486
1334
        self.assertFileEqual('newcontent', new_path)
1487
 
        if osutils.host_os_dereferences_symlinks():
 
1335
        if osutils.has_symlinks():
1488
1336
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1489
1337
        # make sure we can create files with the same parent directories
1490
 
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1491
 
 
1492
 
 
1493
 
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
1494
 
 
1495
 
    def test_encodable_filename(self):
1496
 
        # Just checks file path for external diff tool.
1497
 
        # We cannot change CPython's internal encoding used by os.exec*.
1498
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1499
 
                                    None, None, None)
1500
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1501
 
            encoding = scenario['encoding']
1502
 
            dirname = scenario['info']['directory']
1503
 
            filename = scenario['info']['filename']
1504
 
 
1505
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1506
 
            relpath = dirname + u'/' + filename
1507
 
            fullpath = diffobj._safe_filename('safe', relpath)
1508
 
            self.assertEqual(fullpath,
1509
 
                             fullpath.encode(encoding).decode(encoding))
1510
 
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
1511
 
 
1512
 
    def test_unencodable_filename(self):
1513
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1514
 
                                    None, None, None)
1515
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1516
 
            encoding = scenario['encoding']
1517
 
            dirname = scenario['info']['directory']
1518
 
            filename = scenario['info']['filename']
1519
 
 
1520
 
            if encoding == 'iso-8859-1':
1521
 
                encoding = 'iso-8859-2'
1522
 
            else:
1523
 
                encoding = 'iso-8859-1'
1524
 
 
1525
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1526
 
            relpath = dirname + u'/' + filename
1527
 
            fullpath = diffobj._safe_filename('safe', relpath)
1528
 
            self.assertEqual(fullpath,
1529
 
                             fullpath.encode(encoding).decode(encoding))
1530
 
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
1531
 
 
1532
 
 
1533
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1534
 
 
1535
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1536
 
        """Call get_trees_and_branches_to_diff_locked."""
1537
 
        return diff.get_trees_and_branches_to_diff_locked(
1538
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1539
 
 
1540
 
    def test_basic(self):
1541
 
        tree = self.make_branch_and_tree('tree')
1542
 
        (old_tree, new_tree,
1543
 
         old_branch, new_branch,
1544
 
         specific_files, extra_trees) = self.call_gtabtd(
1545
 
             ['tree'], None, None, None)
1546
 
 
1547
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1548
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1549
 
                         old_tree.get_revision_id())
1550
 
        self.assertEqual(tree.basedir, new_tree.basedir)
1551
 
        self.assertEqual(tree.branch.base, old_branch.base)
1552
 
        self.assertEqual(tree.branch.base, new_branch.base)
1553
 
        self.assertIs(None, specific_files)
1554
 
        self.assertIs(None, extra_trees)
1555
 
 
1556
 
    def test_with_rev_specs(self):
1557
 
        tree = self.make_branch_and_tree('tree')
1558
 
        self.build_tree_contents([('tree/file', 'oldcontent')])
1559
 
        tree.add('file', 'file-id')
1560
 
        tree.commit('old tree', timestamp=0, rev_id="old-id")
1561
 
        self.build_tree_contents([('tree/file', 'newcontent')])
1562
 
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1563
 
 
1564
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1565
 
                     revisionspec.RevisionSpec.from_string('2')]
1566
 
        (old_tree, new_tree,
1567
 
         old_branch, new_branch,
1568
 
         specific_files, extra_trees) = self.call_gtabtd(
1569
 
            ['tree'], revisions, None, None)
1570
 
 
1571
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1572
 
        self.assertEqual("old-id", old_tree.get_revision_id())
1573
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
1574
 
        self.assertEqual("new-id", new_tree.get_revision_id())
1575
 
        self.assertEqual(tree.branch.base, old_branch.base)
1576
 
        self.assertEqual(tree.branch.base, new_branch.base)
1577
 
        self.assertIs(None, specific_files)
1578
 
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
 
1338
        diff_obj._prepare_files('file-id', 'oldname2', 'newname2')