← 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: Ian Clatworthy
  • Date: 2007-08-13 14:33:10 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070813143310-twhj4la0qnupvze8
Added Quick Start Summary

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2011 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
18
from cStringIO import StringIO
 
19
import errno
19
20
import subprocess
20
 
import sys
21
 
import tempfile
22
 
 
23
 
from bzrlib import (
24
 
    diff,
25
 
    errors,
26
 
    osutils,
27
 
    patiencediff,
28
 
    _patiencediff_py,
29
 
    revision as _mod_revision,
30
 
    revisionspec,
31
 
    revisiontree,
32
 
    tests,
33
 
    transform,
34
 
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import features, EncodingAdapter
37
 
from bzrlib.tests.blackbox.test_diff import subst_dates
38
 
from bzrlib.tests import (
39
 
    features,
40
 
    )
41
 
 
 
21
from tempfile import TemporaryFile
 
22
 
 
23
from bzrlib.diff import internal_diff, external_diff, show_diff_trees
 
24
from bzrlib.errors import BinaryFile, NoDiff
 
25
import bzrlib.osutils as osutils
 
26
import bzrlib.patiencediff
 
27
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
28
                          TestCaseInTempDir, TestSkipped)
 
29
 
 
30
 
 
31
class _UnicodeFilename(Feature):
 
32
    """Does the filesystem support Unicode filenames?"""
 
33
 
 
34
    def _probe(self):
 
35
        try:
 
36
            os.stat(u'\u03b1')
 
37
        except UnicodeEncodeError:
 
38
            return False
 
39
        except (IOError, OSError):
 
40
            # The filesystem allows the Unicode filename but the file doesn't
 
41
            # exist.
 
42
            return True
 
43
        else:
 
44
            # The filesystem allows the Unicode filename and the file exists,
 
45
            # for some reason.
 
46
            return True
 
47
 
 
48
UnicodeFilename = _UnicodeFilename()
 
49
 
 
50
 
 
51
class TestUnicodeFilename(TestCase):
 
52
 
 
53
    def test_probe_passes(self):
 
54
        """UnicodeFilename._probe passes."""
 
55
        # We can't test much more than that because the behaviour depends
 
56
        # on the platform.
 
57
        UnicodeFilename._probe()
 
58
        
42
59
 
43
60
def udiff_lines(old, new, allow_binary=False):
44
61
    output = StringIO()
45
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
62
    internal_diff('old', old, 'new', new, output, allow_binary)
46
63
    output.seek(0, 0)
47
64
    return output.readlines()
48
65
 
52
69
        # StringIO has no fileno, so it tests a different codepath
53
70
        output = StringIO()
54
71
    else:
55
 
        output = tempfile.TemporaryFile()
 
72
        output = TemporaryFile()
56
73
    try:
57
 
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
58
 
    except errors.NoDiff:
59
 
        raise tests.TestSkipped('external "diff" not present to test')
 
74
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
75
    except NoDiff:
 
76
        raise TestSkipped('external "diff" not present to test')
60
77
    output.seek(0, 0)
61
78
    lines = output.readlines()
62
79
    output.close()
63
80
    return lines
64
81
 
65
82
 
66
 
class TestDiff(tests.TestCase):
 
83
class TestDiff(TestCase):
67
84
 
68
85
    def test_add_nl(self):
69
86
        """diff generates a valid diff for patches that add a newline"""
105
122
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
106
123
 
107
124
    def test_binary_lines(self):
108
 
        empty = []
109
 
        uni_lines = [1023 * 'a' + '\x00']
110
 
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
111
 
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
112
 
        udiff_lines(uni_lines , empty, allow_binary=True)
113
 
        udiff_lines(empty, uni_lines, allow_binary=True)
 
125
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
126
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
127
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
128
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
114
129
 
115
130
    def test_external_diff(self):
116
131
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
126
141
        self.check_patch(lines)
127
142
 
128
143
    def test_external_diff_binary_lang_c(self):
 
144
        old_env = {}
129
145
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
130
 
            self.overrideEnv(lang, 'C')
131
 
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
132
 
        # Older versions of diffutils say "Binary files", newer
133
 
        # versions just say "Files".
134
 
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
135
 
        self.assertEquals(lines[1:], ['\n'])
 
146
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
147
        try:
 
148
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
149
            # Older versions of diffutils say "Binary files", newer
 
150
            # versions just say "Files".
 
151
            self.assertContainsRe(lines[0],
 
152
                                  '(Binary f|F)iles old and new differ\n')
 
153
            self.assertEquals(lines[1:], ['\n'])
 
154
        finally:
 
155
            for lang, old_val in old_env.iteritems():
 
156
                osutils.set_or_unset_env(lang, old_val)
136
157
 
137
158
    def test_no_external_diff(self):
138
159
        """Check that NoDiff is raised when diff is not available"""
139
 
        # Make sure no 'diff' command is available
140
 
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
141
 
        self.overrideEnv('PATH', '')
142
 
        self.assertRaises(errors.NoDiff, diff.external_diff,
143
 
                          'old', ['boo\n'], 'new', ['goo\n'],
144
 
                          StringIO(), diff_opts=['-u'])
145
 
 
 
160
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
161
        orig_path = os.environ['PATH']
 
162
        try:
 
163
            os.environ['PATH'] = ''
 
164
            self.assertRaises(NoDiff, external_diff,
 
165
                              'old', ['boo\n'], 'new', ['goo\n'],
 
166
                              StringIO(), diff_opts=['-u'])
 
167
        finally:
 
168
            os.environ['PATH'] = orig_path
 
169
        
146
170
    def test_internal_diff_default(self):
147
171
        # Default internal diff encoding is utf8
148
172
        output = StringIO()
149
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
150
 
                           u'new_\xe5', ['new_text\n'], output)
 
173
        internal_diff(u'old_\xb5', ['old_text\n'],
 
174
                    u'new_\xe5', ['new_text\n'], output)
151
175
        lines = output.getvalue().splitlines(True)
152
176
        self.check_patch(lines)
153
177
        self.assertEquals(['--- old_\xc2\xb5\n',
161
185
 
162
186
    def test_internal_diff_utf8(self):
163
187
        output = StringIO()
164
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
165
 
                           u'new_\xe5', ['new_text\n'], output,
166
 
                           path_encoding='utf8')
 
188
        internal_diff(u'old_\xb5', ['old_text\n'],
 
189
                    u'new_\xe5', ['new_text\n'], output,
 
190
                    path_encoding='utf8')
167
191
        lines = output.getvalue().splitlines(True)
168
192
        self.check_patch(lines)
169
193
        self.assertEquals(['--- old_\xc2\xb5\n',
177
201
 
178
202
    def test_internal_diff_iso_8859_1(self):
179
203
        output = StringIO()
180
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
181
 
                           u'new_\xe5', ['new_text\n'], output,
182
 
                           path_encoding='iso-8859-1')
 
204
        internal_diff(u'old_\xb5', ['old_text\n'],
 
205
                    u'new_\xe5', ['new_text\n'], output,
 
206
                    path_encoding='iso-8859-1')
183
207
        lines = output.getvalue().splitlines(True)
184
208
        self.check_patch(lines)
185
209
        self.assertEquals(['--- old_\xb5\n',
191
215
                          ]
192
216
                          , lines)
193
217
 
194
 
    def test_internal_diff_no_content(self):
195
 
        output = StringIO()
196
 
        diff.internal_diff(u'old', [], u'new', [], output)
197
 
        self.assertEqual('', output.getvalue())
198
 
 
199
 
    def test_internal_diff_no_changes(self):
200
 
        output = StringIO()
201
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
202
 
                           u'new', ['text\n', 'contents\n'],
203
 
                           output)
204
 
        self.assertEqual('', output.getvalue())
205
 
 
206
218
    def test_internal_diff_returns_bytes(self):
207
219
        import StringIO
208
220
        output = StringIO.StringIO()
209
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
210
 
                            u'new_\xe5', ['new_text\n'], output)
211
 
        self.assertIsInstance(output.getvalue(), str,
 
221
        internal_diff(u'old_\xb5', ['old_text\n'],
 
222
                    u'new_\xe5', ['new_text\n'], output)
 
223
        self.failUnless(isinstance(output.getvalue(), str),
212
224
            'internal_diff should return bytestrings')
213
225
 
214
226
 
215
 
class TestDiffFiles(tests.TestCaseInTempDir):
 
227
class TestDiffFiles(TestCaseInTempDir):
216
228
 
217
229
    def test_external_diff_binary(self):
218
230
        """The output when using external diff should use diff's i18n error"""
231
243
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
232
244
 
233
245
 
234
 
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
235
 
    output = StringIO()
236
 
    if working_tree is not None:
237
 
        extra_trees = (working_tree,)
238
 
    else:
239
 
        extra_trees = ()
240
 
    diff.show_diff_trees(tree1, tree2, output,
241
 
        specific_files=specific_files,
242
 
        extra_trees=extra_trees, old_label='old/',
243
 
        new_label='new/')
244
 
    return output.getvalue()
245
 
 
246
 
 
247
 
class TestDiffDates(tests.TestCaseWithTransport):
 
246
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
247
    """Has a helper for running show_diff_trees"""
 
248
 
 
249
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
250
        output = StringIO()
 
251
        if working_tree is not None:
 
252
            extra_trees = (working_tree,)
 
253
        else:
 
254
            extra_trees = ()
 
255
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
256
                        extra_trees=extra_trees, old_label='old/',
 
257
                        new_label='new/')
 
258
        return output.getvalue()
 
259
 
 
260
 
 
261
class TestDiffDates(TestShowDiffTreesHelper):
248
262
 
249
263
    def setUp(self):
250
264
        super(TestDiffDates, self).setUp()
285
299
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
286
300
 
287
301
    def test_diff_rev_tree_working_tree(self):
288
 
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
 
302
        output = self.get_diff(self.wt.basis_tree(), self.wt)
289
303
        # note that the date for old/file1 is from rev 2 rather than from
290
304
        # the basis revision (rev 4)
291
305
        self.assertEqualDiff(output, '''\
301
315
    def test_diff_rev_tree_rev_tree(self):
302
316
        tree1 = self.b.repository.revision_tree('rev-2')
303
317
        tree2 = self.b.repository.revision_tree('rev-3')
304
 
        output = get_diff_as_string(tree1, tree2)
 
318
        output = self.get_diff(tree1, tree2)
305
319
        self.assertEqualDiff(output, '''\
306
320
=== modified file 'file2'
307
321
--- old/file2\t2006-04-01 00:00:00 +0000
311
325
+file2 contents at rev 3
312
326
 
313
327
''')
314
 
 
 
328
        
315
329
    def test_diff_add_files(self):
316
 
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
 
330
        tree1 = self.b.repository.revision_tree(None)
317
331
        tree2 = self.b.repository.revision_tree('rev-1')
318
 
        output = get_diff_as_string(tree1, tree2)
 
332
        output = self.get_diff(tree1, tree2)
319
333
        # the files have the epoch time stamp for the tree in which
320
334
        # they don't exist.
321
335
        self.assertEqualDiff(output, '''\
336
350
    def test_diff_remove_files(self):
337
351
        tree1 = self.b.repository.revision_tree('rev-3')
338
352
        tree2 = self.b.repository.revision_tree('rev-4')
339
 
        output = get_diff_as_string(tree1, tree2)
 
353
        output = self.get_diff(tree1, tree2)
340
354
        # the file has the epoch time stamp for the tree in which
341
355
        # it doesn't exist.
342
356
        self.assertEqualDiff(output, '''\
353
367
        self.wt.rename_one('file1', 'file1b')
354
368
        old_tree = self.b.repository.revision_tree('rev-1')
355
369
        new_tree = self.b.repository.revision_tree('rev-4')
356
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
 
370
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
357
371
                            working_tree=self.wt)
358
372
        self.assertContainsRe(out, 'file1\t')
359
373
 
365
379
        self.wt.rename_one('file1', 'dir1/file1')
366
380
        old_tree = self.b.repository.revision_tree('rev-1')
367
381
        new_tree = self.b.repository.revision_tree('rev-4')
368
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
 
382
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
369
383
                            working_tree=self.wt)
370
384
        self.assertContainsRe(out, 'file1\t')
371
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
 
385
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
372
386
                            working_tree=self.wt)
373
387
        self.assertNotContainsRe(out, 'file1\t')
374
388
 
375
389
 
376
 
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
390
 
 
391
class TestShowDiffTrees(TestShowDiffTreesHelper):
377
392
    """Direct tests for show_diff_trees"""
378
393
 
379
394
    def test_modified_file(self):
384
399
        tree.commit('one', rev_id='rev-1')
385
400
 
386
401
        self.build_tree_contents([('tree/file', 'new contents\n')])
387
 
        d = get_diff_as_string(tree.basis_tree(), tree)
388
 
        self.assertContainsRe(d, "=== modified file 'file'\n")
389
 
        self.assertContainsRe(d, '--- old/file\t')
390
 
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
391
 
        self.assertContainsRe(d, '-contents\n'
392
 
                                 '\\+new contents\n')
 
402
        diff = self.get_diff(tree.basis_tree(), tree)
 
403
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
404
        self.assertContainsRe(diff, '--- old/file\t')
 
405
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
406
        self.assertContainsRe(diff, '-contents\n'
 
407
                                    '\\+new contents\n')
393
408
 
394
409
    def test_modified_file_in_renamed_dir(self):
395
410
        """Test when a file is modified in a renamed directory."""
401
416
 
402
417
        tree.rename_one('dir', 'other')
403
418
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
404
 
        d = get_diff_as_string(tree.basis_tree(), tree)
405
 
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
406
 
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
419
        diff = self.get_diff(tree.basis_tree(), tree)
 
420
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
421
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
407
422
        # XXX: This is technically incorrect, because it used to be at another
408
423
        # location. What to do?
409
 
        self.assertContainsRe(d, '--- old/dir/file\t')
410
 
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
411
 
        self.assertContainsRe(d, '-contents\n'
412
 
                                 '\\+new contents\n')
 
424
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
425
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
426
        self.assertContainsRe(diff, '-contents\n'
 
427
                                    '\\+new contents\n')
413
428
 
414
429
    def test_renamed_directory(self):
415
430
        """Test when only a directory is only renamed."""
420
435
        tree.commit('one', rev_id='rev-1')
421
436
 
422
437
        tree.rename_one('dir', 'newdir')
423
 
        d = get_diff_as_string(tree.basis_tree(), tree)
 
438
        diff = self.get_diff(tree.basis_tree(), tree)
424
439
        # Renaming a directory should be a single "you renamed this dir" even
425
440
        # when there are files inside.
426
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
441
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
427
442
 
428
443
    def test_renamed_file(self):
429
444
        """Test when a file is only renamed."""
433
448
        tree.commit('one', rev_id='rev-1')
434
449
 
435
450
        tree.rename_one('file', 'newname')
436
 
        d = get_diff_as_string(tree.basis_tree(), tree)
437
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
451
        diff = self.get_diff(tree.basis_tree(), tree)
 
452
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
438
453
        # We shouldn't have a --- or +++ line, because there is no content
439
454
        # change
440
 
        self.assertNotContainsRe(d, '---')
 
455
        self.assertNotContainsRe(diff, '---')
441
456
 
442
457
    def test_renamed_and_modified_file(self):
443
458
        """Test when a file is only renamed."""
448
463
 
449
464
        tree.rename_one('file', 'newname')
450
465
        self.build_tree_contents([('tree/newname', 'new contents\n')])
451
 
        d = get_diff_as_string(tree.basis_tree(), tree)
452
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
453
 
        self.assertContainsRe(d, '--- old/file\t')
454
 
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
455
 
        self.assertContainsRe(d, '-contents\n'
456
 
                                 '\\+new contents\n')
457
 
 
458
 
 
459
 
    def test_internal_diff_exec_property(self):
460
 
        tree = self.make_branch_and_tree('tree')
461
 
 
462
 
        tt = transform.TreeTransform(tree)
463
 
        tt.new_file('a', tt.root, 'contents\n', 'a-id', True)
464
 
        tt.new_file('b', tt.root, 'contents\n', 'b-id', False)
465
 
        tt.new_file('c', tt.root, 'contents\n', 'c-id', True)
466
 
        tt.new_file('d', tt.root, 'contents\n', 'd-id', False)
467
 
        tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)
468
 
        tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)
469
 
        tt.apply()
470
 
        tree.commit('one', rev_id='rev-1')
471
 
 
472
 
        tt = transform.TreeTransform(tree)
473
 
        tt.set_executability(False, tt.trans_id_file_id('a-id'))
474
 
        tt.set_executability(True, tt.trans_id_file_id('b-id'))
475
 
        tt.set_executability(False, tt.trans_id_file_id('c-id'))
476
 
        tt.set_executability(True, tt.trans_id_file_id('d-id'))
477
 
        tt.apply()
478
 
        tree.rename_one('c', 'new-c')
479
 
        tree.rename_one('d', 'new-d')
480
 
 
481
 
        d = get_diff_as_string(tree.basis_tree(), tree)
482
 
 
483
 
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
484
 
                                  ".*\+x to -x.*\)")
485
 
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
486
 
                                  ".*-x to \+x.*\)")
487
 
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
488
 
                                  ".*\+x to -x.*\)")
489
 
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
490
 
                                  ".*-x to \+x.*\)")
491
 
        self.assertNotContainsRe(d, r"file 'e'")
492
 
        self.assertNotContainsRe(d, r"file 'f'")
 
466
        diff = self.get_diff(tree.basis_tree(), tree)
 
467
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
468
        self.assertContainsRe(diff, '--- old/file\t')
 
469
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
470
        self.assertContainsRe(diff, '-contents\n'
 
471
                                    '\\+new contents\n')
493
472
 
494
473
    def test_binary_unicode_filenames(self):
495
474
        """Test that contents of files are *not* encoded in UTF-8 when there
496
475
        is a binary file in the diff.
497
476
        """
498
477
        # See https://bugs.launchpad.net/bugs/110092.
499
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
478
        self.requireFeature(UnicodeFilename)
500
479
 
501
480
        # This bug isn't triggered with cStringIO.
502
481
        from StringIO import StringIO
510
489
        tree.add([alpha], ['file-id'])
511
490
        tree.add([omega], ['file-id-2'])
512
491
        diff_content = StringIO()
513
 
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
514
 
        d = diff_content.getvalue()
515
 
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
516
 
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
517
 
                              % (alpha_utf8, alpha_utf8))
518
 
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
519
 
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
520
 
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
521
 
 
522
 
    def test_unicode_filename(self):
523
 
        """Test when the filename are unicode."""
524
 
        self.requireFeature(features.UnicodeFilenameFeature)
525
 
 
526
 
        alpha, omega = u'\u03b1', u'\u03c9'
527
 
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
528
 
 
529
 
        tree = self.make_branch_and_tree('tree')
530
 
        self.build_tree_contents([('tree/ren_'+alpha, 'contents\n')])
531
 
        tree.add(['ren_'+alpha], ['file-id-2'])
532
 
        self.build_tree_contents([('tree/del_'+alpha, 'contents\n')])
533
 
        tree.add(['del_'+alpha], ['file-id-3'])
534
 
        self.build_tree_contents([('tree/mod_'+alpha, 'contents\n')])
535
 
        tree.add(['mod_'+alpha], ['file-id-4'])
536
 
 
537
 
        tree.commit('one', rev_id='rev-1')
538
 
 
539
 
        tree.rename_one('ren_'+alpha, 'ren_'+omega)
540
 
        tree.remove('del_'+alpha)
541
 
        self.build_tree_contents([('tree/add_'+alpha, 'contents\n')])
542
 
        tree.add(['add_'+alpha], ['file-id'])
543
 
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
544
 
 
545
 
        d = get_diff_as_string(tree.basis_tree(), tree)
546
 
        self.assertContainsRe(d,
547
 
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
548
 
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
549
 
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
550
 
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
551
 
 
552
 
    def test_unicode_filename_path_encoding(self):
553
 
        """Test for bug #382699: unicode filenames on Windows should be shown
554
 
        in user encoding.
555
 
        """
556
 
        self.requireFeature(features.UnicodeFilenameFeature)
557
 
        # The word 'test' in Russian
558
 
        _russian_test = u'\u0422\u0435\u0441\u0442'
559
 
        directory = _russian_test + u'/'
560
 
        test_txt = _russian_test + u'.txt'
561
 
        u1234 = u'\u1234.txt'
562
 
 
563
 
        tree = self.make_branch_and_tree('.')
564
 
        self.build_tree_contents([
565
 
            (test_txt, 'foo\n'),
566
 
            (u1234, 'foo\n'),
567
 
            (directory, None),
568
 
            ])
569
 
        tree.add([test_txt, u1234, directory])
570
 
 
571
 
        sio = StringIO()
572
 
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
573
 
            path_encoding='cp1251')
574
 
 
575
 
        output = subst_dates(sio.getvalue())
576
 
        shouldbe = ('''\
577
 
=== added directory '%(directory)s'
578
 
=== added file '%(test_txt)s'
579
 
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
580
 
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
581
 
@@ -0,0 +1,1 @@
582
 
+foo
583
 
 
584
 
=== added file '?.txt'
585
 
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
586
 
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
587
 
@@ -0,0 +1,1 @@
588
 
+foo
589
 
 
590
 
''' % {'directory': _russian_test.encode('cp1251'),
591
 
       'test_txt': test_txt.encode('cp1251'),
592
 
      })
593
 
        self.assertEqualDiff(output, shouldbe)
594
 
 
595
 
 
596
 
class DiffWasIs(diff.DiffPath):
597
 
 
598
 
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
599
 
        self.to_file.write('was: ')
600
 
        self.to_file.write(self.old_tree.get_file(file_id).read())
601
 
        self.to_file.write('is: ')
602
 
        self.to_file.write(self.new_tree.get_file(file_id).read())
603
 
        pass
604
 
 
605
 
 
606
 
class TestDiffTree(tests.TestCaseWithTransport):
607
 
 
608
 
    def setUp(self):
609
 
        super(TestDiffTree, self).setUp()
610
 
        self.old_tree = self.make_branch_and_tree('old-tree')
611
 
        self.old_tree.lock_write()
612
 
        self.addCleanup(self.old_tree.unlock)
613
 
        self.new_tree = self.make_branch_and_tree('new-tree')
614
 
        self.new_tree.lock_write()
615
 
        self.addCleanup(self.new_tree.unlock)
616
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
617
 
 
618
 
    def test_diff_text(self):
619
 
        self.build_tree_contents([('old-tree/olddir/',),
620
 
                                  ('old-tree/olddir/oldfile', 'old\n')])
621
 
        self.old_tree.add('olddir')
622
 
        self.old_tree.add('olddir/oldfile', 'file-id')
623
 
        self.build_tree_contents([('new-tree/newdir/',),
624
 
                                  ('new-tree/newdir/newfile', 'new\n')])
625
 
        self.new_tree.add('newdir')
626
 
        self.new_tree.add('newdir/newfile', 'file-id')
627
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
628
 
        differ.diff_text('file-id', None, 'old label', 'new label')
629
 
        self.assertEqual(
630
 
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
631
 
            differ.to_file.getvalue())
632
 
        differ.to_file.seek(0)
633
 
        differ.diff_text(None, 'file-id', 'old label', 'new label')
634
 
        self.assertEqual(
635
 
            '--- old label\n+++ new label\n@@ -0,0 +1,1 @@\n+new\n\n',
636
 
            differ.to_file.getvalue())
637
 
        differ.to_file.seek(0)
638
 
        differ.diff_text('file-id', 'file-id', 'old label', 'new label')
639
 
        self.assertEqual(
640
 
            '--- old label\n+++ new label\n@@ -1,1 +1,1 @@\n-old\n+new\n\n',
641
 
            differ.to_file.getvalue())
642
 
 
643
 
    def test_diff_deletion(self):
644
 
        self.build_tree_contents([('old-tree/file', 'contents'),
645
 
                                  ('new-tree/file', 'contents')])
646
 
        self.old_tree.add('file', 'file-id')
647
 
        self.new_tree.add('file', 'file-id')
648
 
        os.unlink('new-tree/file')
649
 
        self.differ.show_diff(None)
650
 
        self.assertContainsRe(self.differ.to_file.getvalue(), '-contents')
651
 
 
652
 
    def test_diff_creation(self):
653
 
        self.build_tree_contents([('old-tree/file', 'contents'),
654
 
                                  ('new-tree/file', 'contents')])
655
 
        self.old_tree.add('file', 'file-id')
656
 
        self.new_tree.add('file', 'file-id')
657
 
        os.unlink('old-tree/file')
658
 
        self.differ.show_diff(None)
659
 
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
660
 
 
661
 
    def test_diff_symlink(self):
662
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
663
 
        differ.diff_symlink('old target', None)
664
 
        self.assertEqual("=== target was 'old target'\n",
665
 
                         differ.to_file.getvalue())
666
 
 
667
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
668
 
        differ.diff_symlink(None, 'new target')
669
 
        self.assertEqual("=== target is 'new target'\n",
670
 
                         differ.to_file.getvalue())
671
 
 
672
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
673
 
        differ.diff_symlink('old target', 'new target')
674
 
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
675
 
                         differ.to_file.getvalue())
676
 
 
677
 
    def test_diff(self):
678
 
        self.build_tree_contents([('old-tree/olddir/',),
679
 
                                  ('old-tree/olddir/oldfile', 'old\n')])
680
 
        self.old_tree.add('olddir')
681
 
        self.old_tree.add('olddir/oldfile', 'file-id')
682
 
        self.build_tree_contents([('new-tree/newdir/',),
683
 
                                  ('new-tree/newdir/newfile', 'new\n')])
684
 
        self.new_tree.add('newdir')
685
 
        self.new_tree.add('newdir/newfile', 'file-id')
686
 
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
687
 
        self.assertContainsRe(
688
 
            self.differ.to_file.getvalue(),
689
 
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
690
 
             ' \@\@\n-old\n\+new\n\n')
691
 
 
692
 
    def test_diff_kind_change(self):
693
 
        self.requireFeature(features.SymlinkFeature)
694
 
        self.build_tree_contents([('old-tree/olddir/',),
695
 
                                  ('old-tree/olddir/oldfile', 'old\n')])
696
 
        self.old_tree.add('olddir')
697
 
        self.old_tree.add('olddir/oldfile', 'file-id')
698
 
        self.build_tree(['new-tree/newdir/'])
699
 
        os.symlink('new', 'new-tree/newdir/newfile')
700
 
        self.new_tree.add('newdir')
701
 
        self.new_tree.add('newdir/newfile', 'file-id')
702
 
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
703
 
        self.assertContainsRe(
704
 
            self.differ.to_file.getvalue(),
705
 
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
706
 
             ' \@\@\n-old\n\n')
707
 
        self.assertContainsRe(self.differ.to_file.getvalue(),
708
 
                              "=== target is u'new'\n")
709
 
 
710
 
    def test_diff_directory(self):
711
 
        self.build_tree(['new-tree/new-dir/'])
712
 
        self.new_tree.add('new-dir', 'new-dir-id')
713
 
        self.differ.diff('new-dir-id', None, 'new-dir')
714
 
        self.assertEqual(self.differ.to_file.getvalue(), '')
715
 
 
716
 
    def create_old_new(self):
717
 
        self.build_tree_contents([('old-tree/olddir/',),
718
 
                                  ('old-tree/olddir/oldfile', 'old\n')])
719
 
        self.old_tree.add('olddir')
720
 
        self.old_tree.add('olddir/oldfile', 'file-id')
721
 
        self.build_tree_contents([('new-tree/newdir/',),
722
 
                                  ('new-tree/newdir/newfile', 'new\n')])
723
 
        self.new_tree.add('newdir')
724
 
        self.new_tree.add('newdir/newfile', 'file-id')
725
 
 
726
 
    def test_register_diff(self):
727
 
        self.create_old_new()
728
 
        old_diff_factories = diff.DiffTree.diff_factories
729
 
        diff.DiffTree.diff_factories=old_diff_factories[:]
730
 
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
731
 
        try:
732
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
733
 
        finally:
734
 
            diff.DiffTree.diff_factories = old_diff_factories
735
 
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
736
 
        self.assertNotContainsRe(
737
 
            differ.to_file.getvalue(),
738
 
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
739
 
             ' \@\@\n-old\n\+new\n\n')
740
 
        self.assertContainsRe(differ.to_file.getvalue(),
741
 
                              'was: old\nis: new\n')
742
 
 
743
 
    def test_extra_factories(self):
744
 
        self.create_old_new()
745
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
746
 
                               extra_factories=[DiffWasIs.from_diff_tree])
747
 
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
748
 
        self.assertNotContainsRe(
749
 
            differ.to_file.getvalue(),
750
 
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
751
 
             ' \@\@\n-old\n\+new\n\n')
752
 
        self.assertContainsRe(differ.to_file.getvalue(),
753
 
                              'was: old\nis: new\n')
754
 
 
755
 
    def test_alphabetical_order(self):
756
 
        self.build_tree(['new-tree/a-file'])
757
 
        self.new_tree.add('a-file')
758
 
        self.build_tree(['old-tree/b-file'])
759
 
        self.old_tree.add('b-file')
760
 
        self.differ.show_diff(None)
761
 
        self.assertContainsRe(self.differ.to_file.getvalue(),
762
 
            '.*a-file(.|\n)*b-file')
763
 
 
764
 
 
765
 
class TestPatienceDiffLib(tests.TestCase):
766
 
 
767
 
    def setUp(self):
768
 
        super(TestPatienceDiffLib, self).setUp()
769
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
770
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
771
 
        self._PatienceSequenceMatcher = \
772
 
            _patiencediff_py.PatienceSequenceMatcher_py
773
 
 
774
 
    def test_diff_unicode_string(self):
775
 
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
776
 
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
777
 
        sm = self._PatienceSequenceMatcher(None, a, b)
778
 
        mb = sm.get_matching_blocks()
779
 
        self.assertEquals(35, len(mb))
 
492
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
493
        diff = diff_content.getvalue()
 
494
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
495
        self.assertContainsRe(
 
496
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
497
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
498
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
499
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
 
500
 
 
501
 
 
502
class TestPatienceDiffLib(TestCase):
780
503
 
781
504
    def test_unique_lcs(self):
782
 
        unique_lcs = self._unique_lcs
 
505
        unique_lcs = bzrlib.patiencediff.unique_lcs
783
506
        self.assertEquals(unique_lcs('', ''), [])
784
 
        self.assertEquals(unique_lcs('', 'a'), [])
785
 
        self.assertEquals(unique_lcs('a', ''), [])
786
507
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
787
508
        self.assertEquals(unique_lcs('a', 'b'), [])
788
509
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
789
510
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
790
511
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
791
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
512
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
792
513
                                                         (3,3), (4,4)])
793
514
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
794
515
 
795
516
    def test_recurse_matches(self):
796
517
        def test_one(a, b, matches):
797
518
            test_matches = []
798
 
            self._recurse_matches(
799
 
                a, b, 0, 0, len(a), len(b), test_matches, 10)
 
519
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
 
520
                test_matches, 10)
800
521
            self.assertEquals(test_matches, matches)
801
522
 
802
523
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
803
524
                 [(0, 0), (2, 2), (4, 4)])
804
525
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
805
526
                 [(0, 0), (2, 1), (4, 2)])
806
 
        # Even though 'bc' is not unique globally, and is surrounded by
807
 
        # non-matching lines, we should still match, because they are locally
808
 
        # unique
809
 
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
810
 
                                          (4, 6), (5, 7), (6, 8)])
811
527
 
812
 
        # recurse_matches doesn't match non-unique
 
528
        # recurse_matches doesn't match non-unique 
813
529
        # lines surrounded by bogus text.
814
530
        # The update has been done in patiencediff.SequenceMatcher instead
815
531
 
819
535
        # This is what it currently gives:
820
536
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
821
537
 
822
 
    def assertDiffBlocks(self, a, b, expected_blocks):
823
 
        """Check that the sequence matcher returns the correct blocks.
824
 
 
825
 
        :param a: A sequence to match
826
 
        :param b: Another sequence to match
827
 
        :param expected_blocks: The expected output, not including the final
828
 
            matching block (len(a), len(b), 0)
829
 
        """
830
 
        matcher = self._PatienceSequenceMatcher(None, a, b)
831
 
        blocks = matcher.get_matching_blocks()
832
 
        last = blocks.pop()
833
 
        self.assertEqual((len(a), len(b), 0), last)
834
 
        self.assertEqual(expected_blocks, blocks)
835
 
 
836
538
    def test_matching_blocks(self):
 
539
        def chk_blocks(a, b, expected_blocks):
 
540
            # difflib always adds a signature of the total
 
541
            # length, with no matching entries at the end
 
542
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
543
            blocks = s.get_matching_blocks()
 
544
            self.assertEquals((len(a), len(b), 0), blocks[-1])
 
545
            self.assertEquals(expected_blocks, blocks[:-1])
 
546
 
837
547
        # Some basic matching tests
838
 
        self.assertDiffBlocks('', '', [])
839
 
        self.assertDiffBlocks([], [], [])
840
 
        self.assertDiffBlocks('abc', '', [])
841
 
        self.assertDiffBlocks('', 'abc', [])
842
 
        self.assertDiffBlocks('abcd', 'abcd', [(0, 0, 4)])
843
 
        self.assertDiffBlocks('abcd', 'abce', [(0, 0, 3)])
844
 
        self.assertDiffBlocks('eabc', 'abce', [(1, 0, 3)])
845
 
        self.assertDiffBlocks('eabce', 'abce', [(1, 0, 4)])
846
 
        self.assertDiffBlocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
847
 
        self.assertDiffBlocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
848
 
        self.assertDiffBlocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
849
 
        # This may check too much, but it checks to see that
 
548
        chk_blocks('', '', [])
 
549
        chk_blocks([], [], [])
 
550
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
 
551
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
 
552
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
 
553
        chk_blocks('eabce', 'abce', [(1, 0, 4)])
 
554
        chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
 
555
        chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
 
556
        chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
 
557
        # This may check too much, but it checks to see that 
850
558
        # a copied block stays attached to the previous section,
851
559
        # not the later one.
852
560
        # difflib would tend to grab the trailing longest match
853
561
        # which would make the diff not look right
854
 
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
855
 
                              [(0, 0, 6), (6, 11, 10)])
 
562
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
563
                   [(0, 0, 6), (6, 11, 10)])
856
564
 
857
565
        # make sure it supports passing in lists
858
 
        self.assertDiffBlocks(
 
566
        chk_blocks(
859
567
                   ['hello there\n',
860
568
                    'world\n',
861
569
                    'how are you today?\n'],
865
573
 
866
574
        # non unique lines surrounded by non-matching lines
867
575
        # won't be found
868
 
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
576
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
869
577
 
870
578
        # But they only need to be locally unique
871
 
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
579
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
872
580
 
873
581
        # non unique blocks won't be matched
874
 
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
582
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
875
583
 
876
584
        # but locally unique ones will
877
 
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
585
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
878
586
                                              (5,4,1), (7,5,2), (10,8,1)])
879
587
 
880
 
        self.assertDiffBlocks('abbabbXd', 'cabbabxd', [(7,7,1)])
881
 
        self.assertDiffBlocks('abbabbbb', 'cabbabbc', [])
882
 
        self.assertDiffBlocks('bbbbbbbb', 'cbbbbbbc', [])
883
 
 
884
 
    def test_matching_blocks_tuples(self):
885
 
        # Some basic matching tests
886
 
        self.assertDiffBlocks([], [], [])
887
 
        self.assertDiffBlocks([('a',), ('b',), ('c,')], [], [])
888
 
        self.assertDiffBlocks([], [('a',), ('b',), ('c,')], [])
889
 
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
890
 
                              [('a',), ('b',), ('c,')],
891
 
                              [(0, 0, 3)])
892
 
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
893
 
                              [('a',), ('b',), ('d,')],
894
 
                              [(0, 0, 2)])
895
 
        self.assertDiffBlocks([('d',), ('b',), ('c,')],
896
 
                              [('a',), ('b',), ('c,')],
897
 
                              [(1, 1, 2)])
898
 
        self.assertDiffBlocks([('d',), ('a',), ('b',), ('c,')],
899
 
                              [('a',), ('b',), ('c,')],
900
 
                              [(1, 0, 3)])
901
 
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
902
 
                              [('a', 'b'), ('c', 'X'), ('e', 'f')],
903
 
                              [(0, 0, 1), (2, 2, 1)])
904
 
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
905
 
                              [('a', 'b'), ('c', 'dX'), ('e', 'f')],
906
 
                              [(0, 0, 1), (2, 2, 1)])
 
588
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
 
589
        chk_blocks('abbabbbb', 'cabbabbc', [])
 
590
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
907
591
 
908
592
    def test_opcodes(self):
909
593
        def chk_ops(a, b, expected_codes):
910
 
            s = self._PatienceSequenceMatcher(None, a, b)
 
594
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
911
595
            self.assertEquals(expected_codes, s.get_opcodes())
912
596
 
913
597
        chk_ops('', '', [])
914
598
        chk_ops([], [], [])
915
 
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
916
 
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
917
599
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
918
600
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
919
601
                                 ('replace', 3,4, 3,4)
952
634
                 ('delete', 1,2, 1,1),
953
635
                 ('equal',  2,3, 1,2),
954
636
                ])
955
 
        chk_ops('aBccDe', 'abccde',
 
637
        chk_ops('aBccDe', 'abccde', 
956
638
                [('equal',   0,1, 0,1),
957
639
                 ('replace', 1,5, 1,5),
958
640
                 ('equal',   5,6, 5,6),
959
641
                ])
960
 
        chk_ops('aBcDec', 'abcdec',
 
642
        chk_ops('aBcDec', 'abcdec', 
961
643
                [('equal',   0,1, 0,1),
962
644
                 ('replace', 1,2, 1,2),
963
645
                 ('equal',   2,3, 2,3),
964
646
                 ('replace', 3,4, 3,4),
965
647
                 ('equal',   4,6, 4,6),
966
648
                ])
967
 
        chk_ops('aBcdEcdFg', 'abcdecdfg',
 
649
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
968
650
                [('equal',   0,1, 0,1),
969
651
                 ('replace', 1,8, 1,8),
970
652
                 ('equal',   8,9, 8,9)
971
653
                ])
972
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
 
654
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
973
655
                [('equal',   0,1, 0,1),
974
656
                 ('replace', 1,2, 1,2),
975
657
                 ('equal',   2,4, 2,4),
981
663
                 ('equal',   10,11, 8,9)
982
664
                ])
983
665
 
984
 
    def test_grouped_opcodes(self):
985
 
        def chk_ops(a, b, expected_codes, n=3):
986
 
            s = self._PatienceSequenceMatcher(None, a, b)
987
 
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
988
 
 
989
 
        chk_ops('', '', [])
990
 
        chk_ops([], [], [])
991
 
        chk_ops('abc', '', [[('delete', 0,3, 0,0)]])
992
 
        chk_ops('', 'abc', [[('insert', 0,0, 0,3)]])
993
 
        chk_ops('abcd', 'abcd', [])
994
 
        chk_ops('abcd', 'abce', [[('equal',   0,3, 0,3),
995
 
                                  ('replace', 3,4, 3,4)
996
 
                                 ]])
997
 
        chk_ops('eabc', 'abce', [[('delete', 0,1, 0,0),
998
 
                                 ('equal',  1,4, 0,3),
999
 
                                 ('insert', 4,4, 3,4)
1000
 
                                ]])
1001
 
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
1002
 
                [[('equal',  3,6, 3,6),
1003
 
                  ('insert', 6,6, 6,11),
1004
 
                  ('equal',  6,9, 11,14)
1005
 
                  ]])
1006
 
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
1007
 
                [[('equal',  2,6, 2,6),
1008
 
                  ('insert', 6,6, 6,11),
1009
 
                  ('equal',  6,10, 11,15)
1010
 
                  ]], 4)
1011
 
        chk_ops('Xabcdef', 'abcdef',
1012
 
                [[('delete', 0,1, 0,0),
1013
 
                  ('equal',  1,4, 0,3)
1014
 
                  ]])
1015
 
        chk_ops('abcdef', 'abcdefX',
1016
 
                [[('equal',  3,6, 3,6),
1017
 
                  ('insert', 6,6, 6,7)
1018
 
                  ]])
1019
 
 
1020
 
 
1021
666
    def test_multiple_ranges(self):
1022
667
        # There was an earlier bug where we used a bad set of ranges,
1023
668
        # this triggers that specific bug, to make sure it doesn't regress
1024
 
        self.assertDiffBlocks('abcdefghijklmnop',
1025
 
                              'abcXghiYZQRSTUVWXYZijklmnop',
1026
 
                              [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
1027
 
 
1028
 
        self.assertDiffBlocks('ABCd efghIjk  L',
1029
 
                              'AxyzBCn mo pqrstuvwI1 2  L',
1030
 
                              [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
 
669
        def chk_blocks(a, b, expected_blocks):
 
670
            # difflib always adds a signature of the total
 
671
            # length, with no matching entries at the end
 
672
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
673
            blocks = s.get_matching_blocks()
 
674
            x = blocks.pop()
 
675
            self.assertEquals(x, (len(a), len(b), 0))
 
676
            self.assertEquals(expected_blocks, blocks)
 
677
 
 
678
        chk_blocks('abcdefghijklmnop'
 
679
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
 
680
                 , [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
 
681
 
 
682
        chk_blocks('ABCd efghIjk  L'
 
683
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
 
684
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
1031
685
 
1032
686
        # These are rot13 code snippets.
1033
 
        self.assertDiffBlocks('''\
 
687
        chk_blocks('''\
1034
688
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1035
689
    """
1036
690
    gnxrf_netf = ['svyr*']
1037
691
    gnxrf_bcgvbaf = ['ab-erphefr']
1038
 
 
 
692
  
1039
693
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1040
694
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1041
695
        vs vf_dhvrg():
1049
703
'''.splitlines(True), '''\
1050
704
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1051
705
 
1052
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
 
706
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
1053
707
    nqq gurz.
1054
708
    """
1055
709
    gnxrf_netf = ['svyr*']
1082
736
                 'how are you today?\n']
1083
737
        txt_b = ['hello there\n',
1084
738
                 'how are you today?\n']
1085
 
        unified_diff = patiencediff.unified_diff
1086
 
        psm = self._PatienceSequenceMatcher
1087
 
        self.assertEquals(['--- \n',
1088
 
                           '+++ \n',
 
739
        unified_diff = bzrlib.patiencediff.unified_diff
 
740
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
741
        self.assertEquals([ '---  \n',
 
742
                           '+++  \n',
1089
743
                           '@@ -1,3 +1,2 @@\n',
1090
744
                           ' hello there\n',
1091
745
                           '-world\n',
1096
750
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1097
751
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1098
752
        # This is the result with LongestCommonSubstring matching
1099
 
        self.assertEquals(['--- \n',
1100
 
                           '+++ \n',
 
753
        self.assertEquals(['---  \n',
 
754
                           '+++  \n',
1101
755
                           '@@ -1,6 +1,11 @@\n',
1102
756
                           ' a\n',
1103
757
                           ' b\n',
1112
766
                           ' f\n']
1113
767
                          , list(unified_diff(txt_a, txt_b)))
1114
768
        # And the patience diff
1115
 
        self.assertEquals(['--- \n',
1116
 
                           '+++ \n',
 
769
        self.assertEquals(['---  \n',
 
770
                           '+++  \n',
1117
771
                           '@@ -4,6 +4,11 @@\n',
1118
772
                           ' d\n',
1119
773
                           ' e\n',
1130
784
                          , list(unified_diff(txt_a, txt_b,
1131
785
                                 sequencematcher=psm)))
1132
786
 
1133
 
    def test_patience_unified_diff_with_dates(self):
1134
 
        txt_a = ['hello there\n',
1135
 
                 'world\n',
1136
 
                 'how are you today?\n']
1137
 
        txt_b = ['hello there\n',
1138
 
                 'how are you today?\n']
1139
 
        unified_diff = patiencediff.unified_diff
1140
 
        psm = self._PatienceSequenceMatcher
1141
 
        self.assertEquals(['--- a\t2008-08-08\n',
1142
 
                           '+++ b\t2008-09-09\n',
1143
 
                           '@@ -1,3 +1,2 @@\n',
1144
 
                           ' hello there\n',
1145
 
                           '-world\n',
1146
 
                           ' how are you today?\n'
1147
 
                          ]
1148
 
                          , list(unified_diff(txt_a, txt_b,
1149
 
                                 fromfile='a', tofile='b',
1150
 
                                 fromfiledate='2008-08-08',
1151
 
                                 tofiledate='2008-09-09',
1152
 
                                 sequencematcher=psm)))
1153
 
 
1154
 
 
1155
 
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1156
 
 
1157
 
    _test_needs_features = [features.compiled_patiencediff_feature]
1158
 
 
1159
 
    def setUp(self):
1160
 
        super(TestPatienceDiffLib_c, self).setUp()
1161
 
        from bzrlib import _patiencediff_c
1162
 
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1163
 
        self._recurse_matches = _patiencediff_c.recurse_matches_c
1164
 
        self._PatienceSequenceMatcher = \
1165
 
            _patiencediff_c.PatienceSequenceMatcher_c
1166
 
 
1167
 
    def test_unhashable(self):
1168
 
        """We should get a proper exception here."""
1169
 
        # We need to be able to hash items in the sequence, lists are
1170
 
        # unhashable, and thus cannot be diffed
1171
 
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1172
 
                                         None, [[]], [])
1173
 
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1174
 
                                         None, ['valid', []], [])
1175
 
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1176
 
                                         None, ['valid'], [[]])
1177
 
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
1178
 
                                         None, ['valid'], ['valid', []])
1179
 
 
1180
 
 
1181
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
1182
 
 
1183
 
    def setUp(self):
1184
 
        super(TestPatienceDiffLibFiles, self).setUp()
1185
 
        self._PatienceSequenceMatcher = \
1186
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
787
 
 
788
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1187
789
 
1188
790
    def test_patience_unified_diff_files(self):
1189
791
        txt_a = ['hello there\n',
1194
796
        open('a1', 'wb').writelines(txt_a)
1195
797
        open('b1', 'wb').writelines(txt_b)
1196
798
 
1197
 
        unified_diff_files = patiencediff.unified_diff_files
1198
 
        psm = self._PatienceSequenceMatcher
1199
 
        self.assertEquals(['--- a1\n',
1200
 
                           '+++ b1\n',
 
799
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
 
800
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
 
801
        self.assertEquals(['--- a1 \n',
 
802
                           '+++ b1 \n',
1201
803
                           '@@ -1,3 +1,2 @@\n',
1202
804
                           ' hello there\n',
1203
805
                           '-world\n',
1212
814
        open('b2', 'wb').writelines(txt_b)
1213
815
 
1214
816
        # This is the result with LongestCommonSubstring matching
1215
 
        self.assertEquals(['--- a2\n',
1216
 
                           '+++ b2\n',
 
817
        self.assertEquals(['--- a2 \n',
 
818
                           '+++ b2 \n',
1217
819
                           '@@ -1,6 +1,11 @@\n',
1218
820
                           ' a\n',
1219
821
                           ' b\n',
1229
831
                          , list(unified_diff_files('a2', 'b2')))
1230
832
 
1231
833
        # And the patience diff
1232
 
        self.assertEquals(['--- a2\n',
1233
 
                           '+++ b2\n',
 
834
        self.assertEquals(['--- a2 \n',
 
835
                           '+++ b2 \n',
1234
836
                           '@@ -4,6 +4,11 @@\n',
1235
837
                           ' d\n',
1236
838
                           ' e\n',
1246
848
                          ]
1247
849
                          , list(unified_diff_files('a2', 'b2',
1248
850
                                 sequencematcher=psm)))
1249
 
 
1250
 
 
1251
 
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1252
 
 
1253
 
    _test_needs_features = [features.compiled_patiencediff_feature]
1254
 
 
1255
 
    def setUp(self):
1256
 
        super(TestPatienceDiffLibFiles_c, self).setUp()
1257
 
        from bzrlib import _patiencediff_c
1258
 
        self._PatienceSequenceMatcher = \
1259
 
            _patiencediff_c.PatienceSequenceMatcher_c
1260
 
 
1261
 
 
1262
 
class TestUsingCompiledIfAvailable(tests.TestCase):
1263
 
 
1264
 
    def test_PatienceSequenceMatcher(self):
1265
 
        if features.compiled_patiencediff_feature.available():
1266
 
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1267
 
            self.assertIs(PatienceSequenceMatcher_c,
1268
 
                          patiencediff.PatienceSequenceMatcher)
1269
 
        else:
1270
 
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1271
 
            self.assertIs(PatienceSequenceMatcher_py,
1272
 
                          patiencediff.PatienceSequenceMatcher)
1273
 
 
1274
 
    def test_unique_lcs(self):
1275
 
        if features.compiled_patiencediff_feature.available():
1276
 
            from bzrlib._patiencediff_c import unique_lcs_c
1277
 
            self.assertIs(unique_lcs_c,
1278
 
                          patiencediff.unique_lcs)
1279
 
        else:
1280
 
            from bzrlib._patiencediff_py import unique_lcs_py
1281
 
            self.assertIs(unique_lcs_py,
1282
 
                          patiencediff.unique_lcs)
1283
 
 
1284
 
    def test_recurse_matches(self):
1285
 
        if features.compiled_patiencediff_feature.available():
1286
 
            from bzrlib._patiencediff_c import recurse_matches_c
1287
 
            self.assertIs(recurse_matches_c,
1288
 
                          patiencediff.recurse_matches)
1289
 
        else:
1290
 
            from bzrlib._patiencediff_py import recurse_matches_py
1291
 
            self.assertIs(recurse_matches_py,
1292
 
                          patiencediff.recurse_matches)
1293
 
 
1294
 
 
1295
 
class TestDiffFromTool(tests.TestCaseWithTransport):
1296
 
 
1297
 
    def test_from_string(self):
1298
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
1299
 
        self.addCleanup(diff_obj.finish)
1300
 
        self.assertEqual(['diff', '@old_path', '@new_path'],
1301
 
            diff_obj.command_template)
1302
 
 
1303
 
    def test_from_string_u5(self):
1304
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1305
 
                                                 None, None, None)
1306
 
        self.addCleanup(diff_obj.finish)
1307
 
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1308
 
                         diff_obj.command_template)
1309
 
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1310
 
                         diff_obj._get_command('old-path', 'new-path'))
1311
 
 
1312
 
    def test_from_string_path_with_backslashes(self):
1313
 
        self.requireFeature(features.backslashdir_feature)
1314
 
        tool = 'C:\\Tools\\Diff.exe'
1315
 
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1316
 
        self.addCleanup(diff_obj.finish)
1317
 
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1318
 
                         diff_obj.command_template)
1319
 
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
1320
 
                         diff_obj._get_command('old-path', 'new-path'))
1321
 
 
1322
 
    def test_execute(self):
1323
 
        output = StringIO()
1324
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1325
 
                                      'print "@old_path @new_path"'],
1326
 
                                     None, None, output)
1327
 
        self.addCleanup(diff_obj.finish)
1328
 
        diff_obj._execute('old', 'new')
1329
 
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1330
 
 
1331
 
    def test_excute_missing(self):
1332
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1333
 
                                     None, None, None)
1334
 
        self.addCleanup(diff_obj.finish)
1335
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1336
 
                              'old', 'new')
1337
 
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1338
 
                         ' on this machine', str(e))
1339
 
 
1340
 
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1341
 
        self.requireFeature(features.AttribFeature)
1342
 
        output = StringIO()
1343
 
        tree = self.make_branch_and_tree('tree')
1344
 
        self.build_tree_contents([('tree/file', 'content')])
1345
 
        tree.add('file', 'file-id')
1346
 
        tree.commit('old tree')
1347
 
        tree.lock_read()
1348
 
        self.addCleanup(tree.unlock)
1349
 
        basis_tree = tree.basis_tree()
1350
 
        basis_tree.lock_read()
1351
 
        self.addCleanup(basis_tree.unlock)
1352
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1353
 
                                      'print "@old_path @new_path"'],
1354
 
                                     basis_tree, tree, output)
1355
 
        diff_obj._prepare_files('file-id', 'file', 'file')
1356
 
        # The old content should be readonly
1357
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1358
 
                                    r'R.*old\\file$')
1359
 
        # The new content should use the tree object, not a 'new' file anymore
1360
 
        self.assertEndsWith(tree.basedir, 'work/tree')
1361
 
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1362
 
 
1363
 
    def assertReadableByAttrib(self, cwd, relpath, regex):
1364
 
        proc = subprocess.Popen(['attrib', relpath],
1365
 
                                stdout=subprocess.PIPE,
1366
 
                                cwd=cwd)
1367
 
        (result, err) = proc.communicate()
1368
 
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1369
 
 
1370
 
    def test_prepare_files(self):
1371
 
        output = StringIO()
1372
 
        tree = self.make_branch_and_tree('tree')
1373
 
        self.build_tree_contents([('tree/oldname', 'oldcontent')])
1374
 
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1375
 
        tree.add('oldname', 'file-id')
1376
 
        tree.add('oldname2', 'file2-id')
1377
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1378
 
        tree.commit('old tree', timestamp=315532800)
1379
 
        tree.rename_one('oldname', 'newname')
1380
 
        tree.rename_one('oldname2', 'newname2')
1381
 
        self.build_tree_contents([('tree/newname', 'newcontent')])
1382
 
        self.build_tree_contents([('tree/newname2', 'newcontent2')])
1383
 
        old_tree = tree.basis_tree()
1384
 
        old_tree.lock_read()
1385
 
        self.addCleanup(old_tree.unlock)
1386
 
        tree.lock_read()
1387
 
        self.addCleanup(tree.unlock)
1388
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1389
 
                                      'print "@old_path @new_path"'],
1390
 
                                     old_tree, tree, output)
1391
 
        self.addCleanup(diff_obj.finish)
1392
 
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1393
 
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1394
 
                                                     'newname')
1395
 
        self.assertContainsRe(old_path, 'old/oldname$')
1396
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
1397
 
        self.assertContainsRe(new_path, 'tree/newname$')
1398
 
        self.assertFileEqual('oldcontent', old_path)
1399
 
        self.assertFileEqual('newcontent', new_path)
1400
 
        if osutils.host_os_dereferences_symlinks():
1401
 
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1402
 
        # make sure we can create files with the same parent directories
1403
 
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1404
 
 
1405
 
 
1406
 
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
1407
 
 
1408
 
    def test_encodable_filename(self):
1409
 
        # Just checks file path for external diff tool.
1410
 
        # We cannot change CPython's internal encoding used by os.exec*.
1411
 
        import sys
1412
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1413
 
                                    None, None, None)
1414
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1415
 
            encoding = scenario['encoding']
1416
 
            dirname  = scenario['info']['directory']
1417
 
            filename = scenario['info']['filename']
1418
 
 
1419
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1420
 
            relpath = dirname + u'/' + filename
1421
 
            fullpath = diffobj._safe_filename('safe', relpath)
1422
 
            self.assertEqual(
1423
 
                    fullpath,
1424
 
                    fullpath.encode(encoding).decode(encoding)
1425
 
                    )
1426
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1427
 
 
1428
 
    def test_unencodable_filename(self):
1429
 
        import sys
1430
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1431
 
                                    None, None, None)
1432
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1433
 
            encoding = scenario['encoding']
1434
 
            dirname  = scenario['info']['directory']
1435
 
            filename = scenario['info']['filename']
1436
 
 
1437
 
            if encoding == 'iso-8859-1':
1438
 
                encoding = 'iso-8859-2'
1439
 
            else:
1440
 
                encoding = 'iso-8859-1'
1441
 
 
1442
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1443
 
            relpath = dirname + u'/' + filename
1444
 
            fullpath = diffobj._safe_filename('safe', relpath)
1445
 
            self.assertEqual(
1446
 
                    fullpath,
1447
 
                    fullpath.encode(encoding).decode(encoding)
1448
 
                    )
1449
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1450
 
 
1451
 
 
1452
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1453
 
 
1454
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1455
 
        """Call get_trees_and_branches_to_diff_locked."""
1456
 
        return diff.get_trees_and_branches_to_diff_locked(
1457
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1458
 
 
1459
 
    def test_basic(self):
1460
 
        tree = self.make_branch_and_tree('tree')
1461
 
        (old_tree, new_tree,
1462
 
         old_branch, new_branch,
1463
 
         specific_files, extra_trees) = self.call_gtabtd(
1464
 
             ['tree'], None, None, None)
1465
 
 
1466
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1467
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1468
 
                         old_tree.get_revision_id())
1469
 
        self.assertEqual(tree.basedir, new_tree.basedir)
1470
 
        self.assertEqual(tree.branch.base, old_branch.base)
1471
 
        self.assertEqual(tree.branch.base, new_branch.base)
1472
 
        self.assertIs(None, specific_files)
1473
 
        self.assertIs(None, extra_trees)
1474
 
 
1475
 
    def test_with_rev_specs(self):
1476
 
        tree = self.make_branch_and_tree('tree')
1477
 
        self.build_tree_contents([('tree/file', 'oldcontent')])
1478
 
        tree.add('file', 'file-id')
1479
 
        tree.commit('old tree', timestamp=0, rev_id="old-id")
1480
 
        self.build_tree_contents([('tree/file', 'newcontent')])
1481
 
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1482
 
 
1483
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1484
 
                     revisionspec.RevisionSpec.from_string('2')]
1485
 
        (old_tree, new_tree,
1486
 
         old_branch, new_branch,
1487
 
         specific_files, extra_trees) = self.call_gtabtd(
1488
 
            ['tree'], revisions, None, None)
1489
 
 
1490
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1491
 
        self.assertEqual("old-id", old_tree.get_revision_id())
1492
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
1493
 
        self.assertEqual("new-id", new_tree.get_revision_id())
1494
 
        self.assertEqual(tree.branch.base, old_branch.base)
1495
 
        self.assertEqual(tree.branch.base, new_branch.base)
1496
 
        self.assertIs(None, specific_files)
1497
 
        self.assertEqual(tree.basedir, extra_trees[0].basedir)