← 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: John Arbash Meinel
  • Author(s): Mark Hammond
  • Date: 2008-09-09 17:02:21 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: john@arbash-meinel.com-20080909170221-svim3jw2mrz0amp3
An updated transparent icon for bzr.

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
import sys
 
23
from tempfile import TemporaryFile
21
24
 
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,
 
25
from bzrlib import tests
 
26
from bzrlib.diff import (
 
27
    DiffFromTool,
 
28
    DiffPath,
 
29
    DiffSymlink,
 
30
    DiffTree,
 
31
    DiffText,
 
32
    external_diff,
 
33
    internal_diff,
 
34
    show_diff_trees,
33
35
    )
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
 
36
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
 
37
import bzrlib.osutils as osutils
 
38
import bzrlib.transform as transform
 
39
import bzrlib.patiencediff
 
40
import bzrlib._patiencediff_py
 
41
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
42
                          TestCaseInTempDir, TestSkipped)
 
43
 
 
44
 
 
45
class _AttribFeature(Feature):
 
46
 
 
47
    def _probe(self):
 
48
        if (sys.platform not in ('cygwin', 'win32')):
 
49
            return False
 
50
        try:
 
51
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
 
52
        except OSError, e:
 
53
            return False
 
54
        return (0 == proc.wait())
 
55
 
 
56
    def feature_name(self):
 
57
        return 'attrib Windows command-line tool'
 
58
 
 
59
AttribFeature = _AttribFeature()
 
60
 
 
61
 
 
62
class _CompiledPatienceDiffFeature(Feature):
 
63
 
 
64
    def _probe(self):
 
65
        try:
 
66
            import bzrlib._patiencediff_c
 
67
        except ImportError:
 
68
            return False
 
69
        return True
 
70
 
 
71
    def feature_name(self):
 
72
        return 'bzrlib._patiencediff_c'
 
73
 
 
74
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
43
75
 
44
76
 
45
77
def udiff_lines(old, new, allow_binary=False):
46
78
    output = StringIO()
47
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
79
    internal_diff('old', old, 'new', new, output, allow_binary)
48
80
    output.seek(0, 0)
49
81
    return output.readlines()
50
82
 
54
86
        # StringIO has no fileno, so it tests a different codepath
55
87
        output = StringIO()
56
88
    else:
57
 
        output = tempfile.TemporaryFile()
 
89
        output = TemporaryFile()
58
90
    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')
 
91
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
92
    except NoDiff:
 
93
        raise TestSkipped('external "diff" not present to test')
62
94
    output.seek(0, 0)
63
95
    lines = output.readlines()
64
96
    output.close()
65
97
    return lines
66
98
 
67
99
 
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):
 
100
class TestDiff(TestCase):
92
101
 
93
102
    def test_add_nl(self):
94
103
        """diff generates a valid diff for patches that add a newline"""
95
104
        lines = udiff_lines(['boo'], ['boo\n'])
96
105
        self.check_patch(lines)
97
 
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
 
106
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
98
107
            ## "expected no-nl, got %r" % lines[4]
99
108
 
100
109
    def test_add_nl_2(self):
103
112
        """
104
113
        lines = udiff_lines(['boo'], ['goo\n'])
105
114
        self.check_patch(lines)
106
 
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
 
115
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
107
116
            ## "expected no-nl, got %r" % lines[4]
108
117
 
109
118
    def test_remove_nl(self):
112
121
        """
113
122
        lines = udiff_lines(['boo\n'], ['boo'])
114
123
        self.check_patch(lines)
115
 
        self.assertEqual(lines[5], '\\ No newline at end of file\n')
 
124
        self.assertEquals(lines[5], '\\ No newline at end of file\n')
116
125
            ## "expected no-nl, got %r" % lines[5]
117
126
 
118
127
    def check_patch(self, lines):
119
 
        self.assertTrue(len(lines) > 1)
 
128
        self.assert_(len(lines) > 1)
120
129
            ## "Not enough lines for a file header for patch:\n%s" % "".join(lines)
121
 
        self.assertTrue(lines[0].startswith ('---'))
 
130
        self.assert_(lines[0].startswith ('---'))
122
131
            ## 'No orig line for patch:\n%s' % "".join(lines)
123
 
        self.assertTrue(lines[1].startswith ('+++'))
 
132
        self.assert_(lines[1].startswith ('+++'))
124
133
            ## 'No mod line for patch:\n%s' % "".join(lines)
125
 
        self.assertTrue(len(lines) > 2)
 
134
        self.assert_(len(lines) > 2)
126
135
            ## "No hunks for patch:\n%s" % "".join(lines)
127
 
        self.assertTrue(lines[2].startswith('@@'))
 
136
        self.assert_(lines[2].startswith('@@'))
128
137
            ## "No hunk header for patch:\n%s" % "".join(lines)
129
 
        self.assertTrue('@@' in lines[2][2:])
 
138
        self.assert_('@@' in lines[2][2:])
130
139
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
131
140
 
132
141
    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)
 
142
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
143
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
144
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
145
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
139
146
 
140
147
    def test_external_diff(self):
141
148
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
151
158
        self.check_patch(lines)
152
159
 
153
160
    def test_external_diff_binary_lang_c(self):
 
161
        old_env = {}
154
162
        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'])
 
163
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
164
        try:
 
165
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
166
            # Older versions of diffutils say "Binary files", newer
 
167
            # versions just say "Files".
 
168
            self.assertContainsRe(lines[0],
 
169
                                  '(Binary f|F)iles old and new differ\n')
 
170
            self.assertEquals(lines[1:], ['\n'])
 
171
        finally:
 
172
            for lang, old_val in old_env.iteritems():
 
173
                osutils.set_or_unset_env(lang, old_val)
161
174
 
162
175
    def test_no_external_diff(self):
163
176
        """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
 
 
 
177
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
178
        orig_path = os.environ['PATH']
 
179
        try:
 
180
            os.environ['PATH'] = ''
 
181
            self.assertRaises(NoDiff, external_diff,
 
182
                              'old', ['boo\n'], 'new', ['goo\n'],
 
183
                              StringIO(), diff_opts=['-u'])
 
184
        finally:
 
185
            os.environ['PATH'] = orig_path
 
186
        
171
187
    def test_internal_diff_default(self):
172
188
        # Default internal diff encoding is utf8
173
189
        output = StringIO()
174
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
175
 
                           u'new_\xe5', ['new_text\n'], output)
 
190
        internal_diff(u'old_\xb5', ['old_text\n'],
 
191
                    u'new_\xe5', ['new_text\n'], output)
176
192
        lines = output.getvalue().splitlines(True)
177
193
        self.check_patch(lines)
178
 
        self.assertEqual(['--- old_\xc2\xb5\n',
 
194
        self.assertEquals(['--- old_\xc2\xb5\n',
179
195
                           '+++ new_\xc3\xa5\n',
180
196
                           '@@ -1,1 +1,1 @@\n',
181
197
                           '-old_text\n',
186
202
 
187
203
    def test_internal_diff_utf8(self):
188
204
        output = StringIO()
189
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
190
 
                           u'new_\xe5', ['new_text\n'], output,
191
 
                           path_encoding='utf8')
 
205
        internal_diff(u'old_\xb5', ['old_text\n'],
 
206
                    u'new_\xe5', ['new_text\n'], output,
 
207
                    path_encoding='utf8')
192
208
        lines = output.getvalue().splitlines(True)
193
209
        self.check_patch(lines)
194
 
        self.assertEqual(['--- old_\xc2\xb5\n',
 
210
        self.assertEquals(['--- old_\xc2\xb5\n',
195
211
                           '+++ new_\xc3\xa5\n',
196
212
                           '@@ -1,1 +1,1 @@\n',
197
213
                           '-old_text\n',
202
218
 
203
219
    def test_internal_diff_iso_8859_1(self):
204
220
        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')
 
221
        internal_diff(u'old_\xb5', ['old_text\n'],
 
222
                    u'new_\xe5', ['new_text\n'], output,
 
223
                    path_encoding='iso-8859-1')
208
224
        lines = output.getvalue().splitlines(True)
209
225
        self.check_patch(lines)
210
 
        self.assertEqual(['--- old_\xb5\n',
 
226
        self.assertEquals(['--- old_\xb5\n',
211
227
                           '+++ new_\xe5\n',
212
228
                           '@@ -1,1 +1,1 @@\n',
213
229
                           '-old_text\n',
218
234
 
219
235
    def test_internal_diff_no_content(self):
220
236
        output = StringIO()
221
 
        diff.internal_diff(u'old', [], u'new', [], output)
 
237
        internal_diff(u'old', [], u'new', [], output)
222
238
        self.assertEqual('', output.getvalue())
223
239
 
224
240
    def test_internal_diff_no_changes(self):
225
241
        output = StringIO()
226
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
227
 
                           u'new', ['text\n', 'contents\n'],
228
 
                           output)
 
242
        internal_diff(u'old', ['text\n', 'contents\n'],
 
243
                      u'new', ['text\n', 'contents\n'],
 
244
                      output)
229
245
        self.assertEqual('', output.getvalue())
230
246
 
231
247
    def test_internal_diff_returns_bytes(self):
232
248
        import StringIO
233
249
        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,
 
250
        internal_diff(u'old_\xb5', ['old_text\n'],
 
251
                    u'new_\xe5', ['new_text\n'], output)
 
252
        self.failUnless(isinstance(output.getvalue(), str),
237
253
            'internal_diff should return bytestrings')
238
254
 
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):
 
255
 
 
256
class TestDiffFiles(TestCaseInTempDir):
304
257
 
305
258
    def test_external_diff_binary(self):
306
259
        """The output when using external diff should use diff's i18n error"""
308
261
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
309
262
 
310
263
        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')
 
264
        open('old', 'wb').write('\x00foobar\n')
 
265
        open('new', 'wb').write('foo\x00bar\n')
313
266
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
314
267
                                     stdin=subprocess.PIPE)
315
268
        out, err = pipe.communicate()
319
272
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
320
273
 
321
274
 
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):
 
275
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
276
    """Has a helper for running show_diff_trees"""
 
277
 
 
278
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
279
        output = StringIO()
 
280
        if working_tree is not None:
 
281
            extra_trees = (working_tree,)
 
282
        else:
 
283
            extra_trees = ()
 
284
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
285
                        extra_trees=extra_trees, old_label='old/',
 
286
                        new_label='new/')
 
287
        return output.getvalue()
 
288
 
 
289
 
 
290
class TestDiffDates(TestShowDiffTreesHelper):
336
291
 
337
292
    def setUp(self):
338
293
        super(TestDiffDates, self).setUp()
373
328
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
374
329
 
375
330
    def test_diff_rev_tree_working_tree(self):
376
 
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
 
331
        output = self.get_diff(self.wt.basis_tree(), self.wt)
377
332
        # note that the date for old/file1 is from rev 2 rather than from
378
333
        # the basis revision (rev 4)
379
334
        self.assertEqualDiff(output, '''\
389
344
    def test_diff_rev_tree_rev_tree(self):
390
345
        tree1 = self.b.repository.revision_tree('rev-2')
391
346
        tree2 = self.b.repository.revision_tree('rev-3')
392
 
        output = get_diff_as_string(tree1, tree2)
 
347
        output = self.get_diff(tree1, tree2)
393
348
        self.assertEqualDiff(output, '''\
394
349
=== modified file 'file2'
395
350
--- old/file2\t2006-04-01 00:00:00 +0000
399
354
+file2 contents at rev 3
400
355
 
401
356
''')
402
 
 
 
357
        
403
358
    def test_diff_add_files(self):
404
 
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
 
359
        tree1 = self.b.repository.revision_tree(None)
405
360
        tree2 = self.b.repository.revision_tree('rev-1')
406
 
        output = get_diff_as_string(tree1, tree2)
 
361
        output = self.get_diff(tree1, tree2)
407
362
        # the files have the epoch time stamp for the tree in which
408
363
        # they don't exist.
409
364
        self.assertEqualDiff(output, '''\
424
379
    def test_diff_remove_files(self):
425
380
        tree1 = self.b.repository.revision_tree('rev-3')
426
381
        tree2 = self.b.repository.revision_tree('rev-4')
427
 
        output = get_diff_as_string(tree1, tree2)
 
382
        output = self.get_diff(tree1, tree2)
428
383
        # the file has the epoch time stamp for the tree in which
429
384
        # it doesn't exist.
430
385
        self.assertEqualDiff(output, '''\
441
396
        self.wt.rename_one('file1', 'file1b')
442
397
        old_tree = self.b.repository.revision_tree('rev-1')
443
398
        new_tree = self.b.repository.revision_tree('rev-4')
444
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
 
399
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
445
400
                            working_tree=self.wt)
446
401
        self.assertContainsRe(out, 'file1\t')
447
402
 
453
408
        self.wt.rename_one('file1', 'dir1/file1')
454
409
        old_tree = self.b.repository.revision_tree('rev-1')
455
410
        new_tree = self.b.repository.revision_tree('rev-4')
456
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
 
411
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
457
412
                            working_tree=self.wt)
458
413
        self.assertContainsRe(out, 'file1\t')
459
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
 
414
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
460
415
                            working_tree=self.wt)
461
416
        self.assertNotContainsRe(out, 'file1\t')
462
417
 
463
418
 
464
 
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
419
 
 
420
class TestShowDiffTrees(TestShowDiffTreesHelper):
465
421
    """Direct tests for show_diff_trees"""
466
422
 
467
423
    def test_modified_file(self):
472
428
        tree.commit('one', rev_id='rev-1')
473
429
 
474
430
        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')
 
431
        diff = self.get_diff(tree.basis_tree(), tree)
 
432
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
433
        self.assertContainsRe(diff, '--- old/file\t')
 
434
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
435
        self.assertContainsRe(diff, '-contents\n'
 
436
                                    '\\+new contents\n')
481
437
 
482
438
    def test_modified_file_in_renamed_dir(self):
483
439
        """Test when a file is modified in a renamed directory."""
489
445
 
490
446
        tree.rename_one('dir', 'other')
491
447
        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")
 
448
        diff = self.get_diff(tree.basis_tree(), tree)
 
449
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
450
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
495
451
        # XXX: This is technically incorrect, because it used to be at another
496
452
        # 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')
 
453
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
454
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
455
        self.assertContainsRe(diff, '-contents\n'
 
456
                                    '\\+new contents\n')
501
457
 
502
458
    def test_renamed_directory(self):
503
459
        """Test when only a directory is only renamed."""
508
464
        tree.commit('one', rev_id='rev-1')
509
465
 
510
466
        tree.rename_one('dir', 'newdir')
511
 
        d = get_diff_as_string(tree.basis_tree(), tree)
 
467
        diff = self.get_diff(tree.basis_tree(), tree)
512
468
        # Renaming a directory should be a single "you renamed this dir" even
513
469
        # when there are files inside.
514
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
470
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
515
471
 
516
472
    def test_renamed_file(self):
517
473
        """Test when a file is only renamed."""
521
477
        tree.commit('one', rev_id='rev-1')
522
478
 
523
479
        tree.rename_one('file', 'newname')
524
 
        d = get_diff_as_string(tree.basis_tree(), tree)
525
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
480
        diff = self.get_diff(tree.basis_tree(), tree)
 
481
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
526
482
        # We shouldn't have a --- or +++ line, because there is no content
527
483
        # change
528
 
        self.assertNotContainsRe(d, '---')
 
484
        self.assertNotContainsRe(diff, '---')
529
485
 
530
486
    def test_renamed_and_modified_file(self):
531
487
        """Test when a file is only renamed."""
536
492
 
537
493
        tree.rename_one('file', 'newname')
538
494
        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')
 
495
        diff = self.get_diff(tree.basis_tree(), tree)
 
496
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
497
        self.assertContainsRe(diff, '--- old/file\t')
 
498
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
499
        self.assertContainsRe(diff, '-contents\n'
 
500
                                    '\\+new contents\n')
545
501
 
546
502
 
547
503
    def test_internal_diff_exec_property(self):
566
522
        tree.rename_one('c', 'new-c')
567
523
        tree.rename_one('d', 'new-d')
568
524
 
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'")
 
525
        diff = self.get_diff(tree.basis_tree(), tree)
 
526
 
 
527
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
 
528
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
 
529
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
 
530
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
 
531
        self.assertNotContainsRe(diff, r"file 'e'")
 
532
        self.assertNotContainsRe(diff, r"file 'f'")
 
533
 
581
534
 
582
535
    def test_binary_unicode_filenames(self):
583
536
        """Test that contents of files are *not* encoded in UTF-8 when there
584
537
        is a binary file in the diff.
585
538
        """
586
539
        # See https://bugs.launchpad.net/bugs/110092.
587
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
540
        self.requireFeature(tests.UnicodeFilenameFeature)
588
541
 
589
542
        # This bug isn't triggered with cStringIO.
590
543
        from StringIO import StringIO
598
551
        tree.add([alpha], ['file-id'])
599
552
        tree.add([omega], ['file-id-2'])
600
553
        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,))
 
554
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
555
        diff = diff_content.getvalue()
 
556
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
557
        self.assertContainsRe(
 
558
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
559
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
560
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
561
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
609
562
 
610
563
    def test_unicode_filename(self):
611
564
        """Test when the filename are unicode."""
612
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
565
        self.requireFeature(tests.UnicodeFilenameFeature)
613
566
 
614
567
        alpha, omega = u'\u03b1', u'\u03c9'
615
568
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
630
583
        tree.add(['add_'+alpha], ['file-id'])
631
584
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
632
585
 
633
 
        d = get_diff_as_string(tree.basis_tree(), tree)
634
 
        self.assertContainsRe(d,
 
586
        diff = self.get_diff(tree.basis_tree(), tree)
 
587
        self.assertContainsRe(diff,
635
588
                "=== 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):
 
589
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
590
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
591
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
592
 
 
593
 
 
594
class DiffWasIs(DiffPath):
685
595
 
686
596
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
687
597
        self.to_file.write('was: ')
691
601
        pass
692
602
 
693
603
 
694
 
class TestDiffTree(tests.TestCaseWithTransport):
 
604
class TestDiffTree(TestCaseWithTransport):
695
605
 
696
606
    def setUp(self):
697
 
        super(TestDiffTree, self).setUp()
 
607
        TestCaseWithTransport.setUp(self)
698
608
        self.old_tree = self.make_branch_and_tree('old-tree')
699
609
        self.old_tree.lock_write()
700
610
        self.addCleanup(self.old_tree.unlock)
701
611
        self.new_tree = self.make_branch_and_tree('new-tree')
702
612
        self.new_tree.lock_write()
703
613
        self.addCleanup(self.new_tree.unlock)
704
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
614
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
705
615
 
706
616
    def test_diff_text(self):
707
617
        self.build_tree_contents([('old-tree/olddir/',),
712
622
                                  ('new-tree/newdir/newfile', 'new\n')])
713
623
        self.new_tree.add('newdir')
714
624
        self.new_tree.add('newdir/newfile', 'file-id')
715
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
625
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
716
626
        differ.diff_text('file-id', None, 'old label', 'new label')
717
627
        self.assertEqual(
718
628
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
747
657
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
748
658
 
749
659
    def test_diff_symlink(self):
750
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
660
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
751
661
        differ.diff_symlink('old target', None)
752
662
        self.assertEqual("=== target was 'old target'\n",
753
663
                         differ.to_file.getvalue())
754
664
 
755
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
665
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
756
666
        differ.diff_symlink(None, 'new target')
757
667
        self.assertEqual("=== target is 'new target'\n",
758
668
                         differ.to_file.getvalue())
759
669
 
760
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
670
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
761
671
        differ.diff_symlink('old target', 'new target')
762
672
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
763
673
                         differ.to_file.getvalue())
778
688
             ' \@\@\n-old\n\+new\n\n')
779
689
 
780
690
    def test_diff_kind_change(self):
781
 
        self.requireFeature(features.SymlinkFeature)
 
691
        self.requireFeature(tests.SymlinkFeature)
782
692
        self.build_tree_contents([('old-tree/olddir/',),
783
693
                                  ('old-tree/olddir/oldfile', 'old\n')])
784
694
        self.old_tree.add('olddir')
793
703
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
794
704
             ' \@\@\n-old\n\n')
795
705
        self.assertContainsRe(self.differ.to_file.getvalue(),
796
 
                              "=== target is u'new'\n")
 
706
                              "=== target is 'new'\n")
797
707
 
798
708
    def test_diff_directory(self):
799
709
        self.build_tree(['new-tree/new-dir/'])
813
723
 
814
724
    def test_register_diff(self):
815
725
        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)
 
726
        old_diff_factories = DiffTree.diff_factories
 
727
        DiffTree.diff_factories=old_diff_factories[:]
 
728
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
819
729
        try:
820
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
730
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
821
731
        finally:
822
 
            diff.DiffTree.diff_factories = old_diff_factories
 
732
            DiffTree.diff_factories = old_diff_factories
823
733
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
824
734
        self.assertNotContainsRe(
825
735
            differ.to_file.getvalue(),
830
740
 
831
741
    def test_extra_factories(self):
832
742
        self.create_old_new()
833
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
834
 
                               extra_factories=[DiffWasIs.from_diff_tree])
 
743
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
744
                            extra_factories=[DiffWasIs.from_diff_tree])
835
745
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
836
746
        self.assertNotContainsRe(
837
747
            differ.to_file.getvalue(),
850
760
            '.*a-file(.|\n)*b-file')
851
761
 
852
762
 
853
 
class TestPatienceDiffLib(tests.TestCase):
 
763
class TestPatienceDiffLib(TestCase):
854
764
 
855
765
    def setUp(self):
856
766
        super(TestPatienceDiffLib, self).setUp()
857
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
858
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
767
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
768
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
859
769
        self._PatienceSequenceMatcher = \
860
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
770
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
861
771
 
862
772
    def test_diff_unicode_string(self):
863
773
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
864
774
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
865
775
        sm = self._PatienceSequenceMatcher(None, a, b)
866
776
        mb = sm.get_matching_blocks()
867
 
        self.assertEqual(35, len(mb))
 
777
        self.assertEquals(35, len(mb))
868
778
 
869
779
    def test_unique_lcs(self):
870
780
        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),
 
781
        self.assertEquals(unique_lcs('', ''), [])
 
782
        self.assertEquals(unique_lcs('', 'a'), [])
 
783
        self.assertEquals(unique_lcs('a', ''), [])
 
784
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
 
785
        self.assertEquals(unique_lcs('a', 'b'), [])
 
786
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
 
787
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
 
788
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
 
789
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
880
790
                                                         (3,3), (4,4)])
881
 
        self.assertEqual(unique_lcs('acbac', 'abc'), [(2,1)])
 
791
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
882
792
 
883
793
    def test_recurse_matches(self):
884
794
        def test_one(a, b, matches):
885
795
            test_matches = []
886
796
            self._recurse_matches(
887
797
                a, b, 0, 0, len(a), len(b), test_matches, 10)
888
 
            self.assertEqual(test_matches, matches)
 
798
            self.assertEquals(test_matches, matches)
889
799
 
890
800
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
891
801
                 [(0, 0), (2, 2), (4, 4)])
897
807
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
898
808
                                          (4, 6), (5, 7), (6, 8)])
899
809
 
900
 
        # recurse_matches doesn't match non-unique
 
810
        # recurse_matches doesn't match non-unique 
901
811
        # lines surrounded by bogus text.
902
812
        # The update has been done in patiencediff.SequenceMatcher instead
903
813
 
996
906
    def test_opcodes(self):
997
907
        def chk_ops(a, b, expected_codes):
998
908
            s = self._PatienceSequenceMatcher(None, a, b)
999
 
            self.assertEqual(expected_codes, s.get_opcodes())
 
909
            self.assertEquals(expected_codes, s.get_opcodes())
1000
910
 
1001
911
        chk_ops('', '', [])
1002
912
        chk_ops([], [], [])
1040
950
                 ('delete', 1,2, 1,1),
1041
951
                 ('equal',  2,3, 1,2),
1042
952
                ])
1043
 
        chk_ops('aBccDe', 'abccde',
 
953
        chk_ops('aBccDe', 'abccde', 
1044
954
                [('equal',   0,1, 0,1),
1045
955
                 ('replace', 1,5, 1,5),
1046
956
                 ('equal',   5,6, 5,6),
1047
957
                ])
1048
 
        chk_ops('aBcDec', 'abcdec',
 
958
        chk_ops('aBcDec', 'abcdec', 
1049
959
                [('equal',   0,1, 0,1),
1050
960
                 ('replace', 1,2, 1,2),
1051
961
                 ('equal',   2,3, 2,3),
1052
962
                 ('replace', 3,4, 3,4),
1053
963
                 ('equal',   4,6, 4,6),
1054
964
                ])
1055
 
        chk_ops('aBcdEcdFg', 'abcdecdfg',
 
965
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
1056
966
                [('equal',   0,1, 0,1),
1057
967
                 ('replace', 1,8, 1,8),
1058
968
                 ('equal',   8,9, 8,9)
1059
969
                ])
1060
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
 
970
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
1061
971
                [('equal',   0,1, 0,1),
1062
972
                 ('replace', 1,2, 1,2),
1063
973
                 ('equal',   2,4, 2,4),
1072
982
    def test_grouped_opcodes(self):
1073
983
        def chk_ops(a, b, expected_codes, n=3):
1074
984
            s = self._PatienceSequenceMatcher(None, a, b)
1075
 
            self.assertEqual(expected_codes, list(s.get_grouped_opcodes(n)))
 
985
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
1076
986
 
1077
987
        chk_ops('', '', [])
1078
988
        chk_ops([], [], [])
1123
1033
    """
1124
1034
    gnxrf_netf = ['svyr*']
1125
1035
    gnxrf_bcgvbaf = ['ab-erphefr']
1126
 
 
 
1036
  
1127
1037
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1128
1038
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1129
1039
        vs vf_dhvrg():
1137
1047
'''.splitlines(True), '''\
1138
1048
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1139
1049
 
1140
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
 
1050
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
1141
1051
    nqq gurz.
1142
1052
    """
1143
1053
    gnxrf_netf = ['svyr*']
1170
1080
                 'how are you today?\n']
1171
1081
        txt_b = ['hello there\n',
1172
1082
                 'how are you today?\n']
1173
 
        unified_diff = patiencediff.unified_diff
 
1083
        unified_diff = bzrlib.patiencediff.unified_diff
1174
1084
        psm = self._PatienceSequenceMatcher
1175
 
        self.assertEqual(['--- \n',
1176
 
                           '+++ \n',
 
1085
        self.assertEquals([ '---  \n',
 
1086
                           '+++  \n',
1177
1087
                           '@@ -1,3 +1,2 @@\n',
1178
1088
                           ' hello there\n',
1179
1089
                           '-world\n',
1184
1094
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1185
1095
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1186
1096
        # This is the result with LongestCommonSubstring matching
1187
 
        self.assertEqual(['--- \n',
1188
 
                           '+++ \n',
 
1097
        self.assertEquals(['---  \n',
 
1098
                           '+++  \n',
1189
1099
                           '@@ -1,6 +1,11 @@\n',
1190
1100
                           ' a\n',
1191
1101
                           ' b\n',
1200
1110
                           ' f\n']
1201
1111
                          , list(unified_diff(txt_a, txt_b)))
1202
1112
        # And the patience diff
1203
 
        self.assertEqual(['--- \n',
1204
 
                           '+++ \n',
 
1113
        self.assertEquals(['---  \n',
 
1114
                           '+++  \n',
1205
1115
                           '@@ -4,6 +4,11 @@\n',
1206
1116
                           ' d\n',
1207
1117
                           ' e\n',
1218
1128
                          , list(unified_diff(txt_a, txt_b,
1219
1129
                                 sequencematcher=psm)))
1220
1130
 
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
1131
 
1243
1132
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1244
1133
 
1245
 
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1134
    _test_needs_features = [CompiledPatienceDiffFeature]
1246
1135
 
1247
1136
    def setUp(self):
1248
1137
        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
 
1138
        import bzrlib._patiencediff_c
 
1139
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1140
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
1252
1141
        self._PatienceSequenceMatcher = \
1253
 
            _patiencediff_c.PatienceSequenceMatcher_c
 
1142
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1254
1143
 
1255
1144
    def test_unhashable(self):
1256
1145
        """We should get a proper exception here."""
1266
1155
                                         None, ['valid'], ['valid', []])
1267
1156
 
1268
1157
 
1269
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1158
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1270
1159
 
1271
1160
    def setUp(self):
1272
1161
        super(TestPatienceDiffLibFiles, self).setUp()
1273
1162
        self._PatienceSequenceMatcher = \
1274
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
1163
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1275
1164
 
1276
1165
    def test_patience_unified_diff_files(self):
1277
1166
        txt_a = ['hello there\n',
1279
1168
                 'how are you today?\n']
1280
1169
        txt_b = ['hello there\n',
1281
1170
                 '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)
 
1171
        open('a1', 'wb').writelines(txt_a)
 
1172
        open('b1', 'wb').writelines(txt_b)
1284
1173
 
1285
 
        unified_diff_files = patiencediff.unified_diff_files
 
1174
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1286
1175
        psm = self._PatienceSequenceMatcher
1287
 
        self.assertEqual(['--- a1\n',
1288
 
                           '+++ b1\n',
 
1176
        self.assertEquals(['--- a1 \n',
 
1177
                           '+++ b1 \n',
1289
1178
                           '@@ -1,3 +1,2 @@\n',
1290
1179
                           ' hello there\n',
1291
1180
                           '-world\n',
1296
1185
 
1297
1186
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1298
1187
        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)
 
1188
        open('a2', 'wb').writelines(txt_a)
 
1189
        open('b2', 'wb').writelines(txt_b)
1301
1190
 
1302
1191
        # This is the result with LongestCommonSubstring matching
1303
 
        self.assertEqual(['--- a2\n',
1304
 
                           '+++ b2\n',
 
1192
        self.assertEquals(['--- a2 \n',
 
1193
                           '+++ b2 \n',
1305
1194
                           '@@ -1,6 +1,11 @@\n',
1306
1195
                           ' a\n',
1307
1196
                           ' b\n',
1317
1206
                          , list(unified_diff_files('a2', 'b2')))
1318
1207
 
1319
1208
        # 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)))
 
1209
        self.assertEquals(['--- a2 \n',
 
1210
                           '+++ b2 \n',
 
1211
                           '@@ -4,6 +4,11 @@\n',
 
1212
                           ' d\n',
 
1213
                           ' e\n',
 
1214
                           ' f\n',
 
1215
                           '+x\n',
 
1216
                           '+y\n',
 
1217
                           '+d\n',
 
1218
                           '+e\n',
 
1219
                           '+f\n',
 
1220
                           ' g\n',
 
1221
                           ' h\n',
 
1222
                           ' i\n',
 
1223
                          ]
 
1224
                          , list(unified_diff_files('a2', 'b2',
 
1225
                                 sequencematcher=psm)))
1336
1226
 
1337
1227
 
1338
1228
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1339
1229
 
1340
 
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1230
    _test_needs_features = [CompiledPatienceDiffFeature]
1341
1231
 
1342
1232
    def setUp(self):
1343
1233
        super(TestPatienceDiffLibFiles_c, self).setUp()
1344
 
        from bzrlib import _patiencediff_c
 
1234
        import bzrlib._patiencediff_c
1345
1235
        self._PatienceSequenceMatcher = \
1346
 
            _patiencediff_c.PatienceSequenceMatcher_c
1347
 
 
1348
 
 
1349
 
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1236
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1237
 
 
1238
 
 
1239
class TestUsingCompiledIfAvailable(TestCase):
1350
1240
 
1351
1241
    def test_PatienceSequenceMatcher(self):
1352
 
        if features.compiled_patiencediff_feature.available():
 
1242
        if CompiledPatienceDiffFeature.available():
1353
1243
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1354
1244
            self.assertIs(PatienceSequenceMatcher_c,
1355
 
                          patiencediff.PatienceSequenceMatcher)
 
1245
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1356
1246
        else:
1357
1247
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1358
1248
            self.assertIs(PatienceSequenceMatcher_py,
1359
 
                          patiencediff.PatienceSequenceMatcher)
 
1249
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1360
1250
 
1361
1251
    def test_unique_lcs(self):
1362
 
        if features.compiled_patiencediff_feature.available():
 
1252
        if CompiledPatienceDiffFeature.available():
1363
1253
            from bzrlib._patiencediff_c import unique_lcs_c
1364
1254
            self.assertIs(unique_lcs_c,
1365
 
                          patiencediff.unique_lcs)
 
1255
                          bzrlib.patiencediff.unique_lcs)
1366
1256
        else:
1367
1257
            from bzrlib._patiencediff_py import unique_lcs_py
1368
1258
            self.assertIs(unique_lcs_py,
1369
 
                          patiencediff.unique_lcs)
 
1259
                          bzrlib.patiencediff.unique_lcs)
1370
1260
 
1371
1261
    def test_recurse_matches(self):
1372
 
        if features.compiled_patiencediff_feature.available():
 
1262
        if CompiledPatienceDiffFeature.available():
1373
1263
            from bzrlib._patiencediff_c import recurse_matches_c
1374
1264
            self.assertIs(recurse_matches_c,
1375
 
                          patiencediff.recurse_matches)
 
1265
                          bzrlib.patiencediff.recurse_matches)
1376
1266
        else:
1377
1267
            from bzrlib._patiencediff_py import recurse_matches_py
1378
1268
            self.assertIs(recurse_matches_py,
1379
 
                          patiencediff.recurse_matches)
1380
 
 
1381
 
 
1382
 
class TestDiffFromTool(tests.TestCaseWithTransport):
 
1269
                          bzrlib.patiencediff.recurse_matches)
 
1270
 
 
1271
 
 
1272
class TestDiffFromTool(TestCaseWithTransport):
1383
1273
 
1384
1274
    def test_from_string(self):
1385
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
 
1275
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
1386
1276
        self.addCleanup(diff_obj.finish)
1387
 
        self.assertEqual(['diff', '@old_path', '@new_path'],
 
1277
        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],
1388
1278
            diff_obj.command_template)
1389
1279
 
1390
1280
    def test_from_string_u5(self):
1391
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1392
 
                                                 None, None, None)
 
1281
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
1393
1282
        self.addCleanup(diff_obj.finish)
1394
 
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
 
1283
        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],
1395
1284
                         diff_obj.command_template)
1396
1285
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1397
1286
                         diff_obj._get_command('old-path', 'new-path'))
1398
1287
 
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
1288
    def test_execute(self):
1410
1289
        output = StringIO()
1411
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1412
 
                                      'print "@old_path @new_path"'],
1413
 
                                     None, None, output)
 
1290
        diff_obj = DiffFromTool(['python', '-c',
 
1291
                                 'print "%(old_path)s %(new_path)s"'],
 
1292
                                None, None, output)
1414
1293
        self.addCleanup(diff_obj.finish)
1415
1294
        diff_obj._execute('old', 'new')
1416
1295
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1417
1296
 
1418
 
    def test_execute_missing(self):
1419
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1420
 
                                     None, None, None)
 
1297
    def test_excute_missing(self):
 
1298
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1299
                                None, None, None)
1421
1300
        self.addCleanup(diff_obj.finish)
1422
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1423
 
                              'old', 'new')
 
1301
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
 
1302
                              'new')
1424
1303
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1425
1304
                         ' on this machine', str(e))
1426
1305
 
1427
1306
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1428
 
        self.requireFeature(features.AttribFeature)
 
1307
        self.requireFeature(AttribFeature)
1429
1308
        output = StringIO()
1430
1309
        tree = self.make_branch_and_tree('tree')
1431
1310
        self.build_tree_contents([('tree/file', 'content')])
1433
1312
        tree.commit('old tree')
1434
1313
        tree.lock_read()
1435
1314
        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)
 
1315
        diff_obj = DiffFromTool(['python', '-c',
 
1316
                                 'print "%(old_path)s %(new_path)s"'],
 
1317
                                tree, tree, output)
1442
1318
        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$')
 
1319
        self.assertReadableByAttrib(diff_obj._root, 'old\\file', r'old\\file')
 
1320
        self.assertReadableByAttrib(diff_obj._root, 'new\\file', r'new\\file')
1449
1321
 
1450
1322
    def assertReadableByAttrib(self, cwd, relpath, regex):
1451
1323
        proc = subprocess.Popen(['attrib', relpath],
1452
1324
                                stdout=subprocess.PIPE,
1453
1325
                                cwd=cwd)
1454
 
        (result, err) = proc.communicate()
1455
 
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
 
1326
        proc.wait()
 
1327
        result = proc.stdout.read()
 
1328
        self.assertContainsRe(result, regex)
1456
1329
 
1457
1330
    def test_prepare_files(self):
1458
1331
        output = StringIO()
1461
1334
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1462
1335
        tree.add('oldname', 'file-id')
1463
1336
        tree.add('oldname2', 'file2-id')
1464
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1465
 
        tree.commit('old tree', timestamp=315532800)
 
1337
        tree.commit('old tree', timestamp=0)
1466
1338
        tree.rename_one('oldname', 'newname')
1467
1339
        tree.rename_one('oldname2', 'newname2')
1468
1340
        self.build_tree_contents([('tree/newname', 'newcontent')])
1472
1344
        self.addCleanup(old_tree.unlock)
1473
1345
        tree.lock_read()
1474
1346
        self.addCleanup(tree.unlock)
1475
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1476
 
                                      'print "@old_path @new_path"'],
1477
 
                                     old_tree, tree, output)
 
1347
        diff_obj = DiffFromTool(['python', '-c',
 
1348
                                 'print "%(old_path)s %(new_path)s"'],
 
1349
                                old_tree, tree, output)
1478
1350
        self.addCleanup(diff_obj.finish)
1479
1351
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1480
1352
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1481
1353
                                                     'newname')
1482
1354
        self.assertContainsRe(old_path, 'old/oldname$')
1483
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
1484
 
        self.assertContainsRe(new_path, 'tree/newname$')
 
1355
        self.assertEqual(0, os.stat(old_path).st_mtime)
 
1356
        self.assertContainsRe(new_path, 'new/newname$')
1485
1357
        self.assertFileEqual('oldcontent', old_path)
1486
1358
        self.assertFileEqual('newcontent', new_path)
1487
1359
        if osutils.host_os_dereferences_symlinks():
1488
1360
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1489
1361
        # make sure we can create files with the same parent directories
1490
1362
        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)