← 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
  • Date: 2013-05-19 14:29:37 UTC
  • mfrom: (6437.63.9 2.5)
  • mto: (6437.63.10 2.5)
  • mto: This revision was merged to the branch mainline in revision 6575.
  • Revision ID: john@arbash-meinel.com-20130519142937-21ykz2n2y2f22za9
Merge in the actual 2.5 branch. It seems I failed before

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
18
18
from cStringIO import StringIO
19
 
import errno
20
19
import subprocess
21
 
from tempfile import TemporaryFile
 
20
import sys
 
21
import tempfile
22
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 (TestCase, TestCaseWithTransport,
28
 
                          TestCaseInTempDir, TestSkipped)
 
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
    )
29
41
 
30
42
 
31
43
def udiff_lines(old, new, allow_binary=False):
32
44
    output = StringIO()
33
 
    internal_diff('old', old, 'new', new, output, allow_binary)
 
45
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
34
46
    output.seek(0, 0)
35
47
    return output.readlines()
36
48
 
40
52
        # StringIO has no fileno, so it tests a different codepath
41
53
        output = StringIO()
42
54
    else:
43
 
        output = TemporaryFile()
 
55
        output = tempfile.TemporaryFile()
44
56
    try:
45
 
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
46
 
    except NoDiff:
47
 
        raise TestSkipped('external "diff" not present to test')
 
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')
48
60
    output.seek(0, 0)
49
61
    lines = output.readlines()
50
62
    output.close()
51
63
    return lines
52
64
 
53
65
 
54
 
class TestDiff(TestCase):
 
66
class TestDiff(tests.TestCase):
55
67
 
56
68
    def test_add_nl(self):
57
69
        """diff generates a valid diff for patches that add a newline"""
93
105
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
94
106
 
95
107
    def test_binary_lines(self):
96
 
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
97
 
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
98
 
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
99
 
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
 
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)
100
114
 
101
115
    def test_external_diff(self):
102
116
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
112
126
        self.check_patch(lines)
113
127
 
114
128
    def test_external_diff_binary_lang_c(self):
115
 
        old_env = {}
116
129
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
117
 
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
118
 
        try:
119
 
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
120
 
            # Older versions of diffutils say "Binary files", newer
121
 
            # versions just say "Files".
122
 
            self.assertContainsRe(lines[0],
123
 
                                  '(Binary f|F)iles old and new differ\n')
124
 
            self.assertEquals(lines[1:], ['\n'])
125
 
        finally:
126
 
            for lang, old_val in old_env.iteritems():
127
 
                osutils.set_or_unset_env(lang, old_val)
 
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'])
128
136
 
129
137
    def test_no_external_diff(self):
130
138
        """Check that NoDiff is raised when diff is not available"""
131
 
        # Use os.environ['PATH'] to make sure no 'diff' command is available
132
 
        orig_path = os.environ['PATH']
133
 
        try:
134
 
            os.environ['PATH'] = ''
135
 
            self.assertRaises(NoDiff, external_diff,
136
 
                              'old', ['boo\n'], 'new', ['goo\n'],
137
 
                              StringIO(), diff_opts=['-u'])
138
 
        finally:
139
 
            os.environ['PATH'] = orig_path
140
 
        
 
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
 
141
146
    def test_internal_diff_default(self):
142
147
        # Default internal diff encoding is utf8
143
148
        output = StringIO()
144
 
        internal_diff(u'old_\xb5', ['old_text\n'],
145
 
                    u'new_\xe5', ['new_text\n'], output)
 
149
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
150
                           u'new_\xe5', ['new_text\n'], output)
146
151
        lines = output.getvalue().splitlines(True)
147
152
        self.check_patch(lines)
148
153
        self.assertEquals(['--- old_\xc2\xb5\n',
156
161
 
157
162
    def test_internal_diff_utf8(self):
158
163
        output = StringIO()
159
 
        internal_diff(u'old_\xb5', ['old_text\n'],
160
 
                    u'new_\xe5', ['new_text\n'], output,
161
 
                    path_encoding='utf8')
 
164
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
165
                           u'new_\xe5', ['new_text\n'], output,
 
166
                           path_encoding='utf8')
162
167
        lines = output.getvalue().splitlines(True)
163
168
        self.check_patch(lines)
164
169
        self.assertEquals(['--- old_\xc2\xb5\n',
172
177
 
173
178
    def test_internal_diff_iso_8859_1(self):
174
179
        output = StringIO()
175
 
        internal_diff(u'old_\xb5', ['old_text\n'],
176
 
                    u'new_\xe5', ['new_text\n'], output,
177
 
                    path_encoding='iso-8859-1')
 
180
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
181
                           u'new_\xe5', ['new_text\n'], output,
 
182
                           path_encoding='iso-8859-1')
178
183
        lines = output.getvalue().splitlines(True)
179
184
        self.check_patch(lines)
180
185
        self.assertEquals(['--- old_\xb5\n',
186
191
                          ]
187
192
                          , lines)
188
193
 
 
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
 
189
206
    def test_internal_diff_returns_bytes(self):
190
207
        import StringIO
191
208
        output = StringIO.StringIO()
192
 
        internal_diff(u'old_\xb5', ['old_text\n'],
193
 
                    u'new_\xe5', ['new_text\n'], output)
194
 
        self.failUnless(isinstance(output.getvalue(), str),
 
209
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
210
                            u'new_\xe5', ['new_text\n'], output)
 
211
        self.assertIsInstance(output.getvalue(), str,
195
212
            'internal_diff should return bytestrings')
196
213
 
197
214
 
198
 
class TestDiffFiles(TestCaseInTempDir):
 
215
class TestDiffFiles(tests.TestCaseInTempDir):
199
216
 
200
217
    def test_external_diff_binary(self):
201
218
        """The output when using external diff should use diff's i18n error"""
203
220
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
204
221
 
205
222
        cmd = ['diff', '-u', '--binary', 'old', 'new']
206
 
        open('old', 'wb').write('\x00foobar\n')
207
 
        open('new', 'wb').write('foo\x00bar\n')
 
223
        with open('old', 'wb') as f: f.write('\x00foobar\n')
 
224
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
208
225
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
209
226
                                     stdin=subprocess.PIPE)
210
227
        out, err = pipe.communicate()
214
231
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
215
232
 
216
233
 
217
 
class TestShowDiffTreesHelper(TestCaseWithTransport):
218
 
    """Has a helper for running show_diff_trees"""
219
 
 
220
 
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
221
 
        output = StringIO()
222
 
        if working_tree is not None:
223
 
            extra_trees = (working_tree,)
224
 
        else:
225
 
            extra_trees = ()
226
 
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
227
 
                        extra_trees=extra_trees, old_label='old/',
228
 
                        new_label='new/')
229
 
        return output.getvalue()
230
 
 
231
 
 
232
 
class TestDiffDates(TestShowDiffTreesHelper):
 
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):
233
248
 
234
249
    def setUp(self):
235
250
        super(TestDiffDates, self).setUp()
270
285
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
271
286
 
272
287
    def test_diff_rev_tree_working_tree(self):
273
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
288
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
274
289
        # note that the date for old/file1 is from rev 2 rather than from
275
290
        # the basis revision (rev 4)
276
291
        self.assertEqualDiff(output, '''\
286
301
    def test_diff_rev_tree_rev_tree(self):
287
302
        tree1 = self.b.repository.revision_tree('rev-2')
288
303
        tree2 = self.b.repository.revision_tree('rev-3')
289
 
        output = self.get_diff(tree1, tree2)
 
304
        output = get_diff_as_string(tree1, tree2)
290
305
        self.assertEqualDiff(output, '''\
291
306
=== modified file 'file2'
292
307
--- old/file2\t2006-04-01 00:00:00 +0000
296
311
+file2 contents at rev 3
297
312
 
298
313
''')
299
 
        
 
314
 
300
315
    def test_diff_add_files(self):
301
 
        tree1 = self.b.repository.revision_tree(None)
 
316
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
302
317
        tree2 = self.b.repository.revision_tree('rev-1')
303
 
        output = self.get_diff(tree1, tree2)
 
318
        output = get_diff_as_string(tree1, tree2)
304
319
        # the files have the epoch time stamp for the tree in which
305
320
        # they don't exist.
306
321
        self.assertEqualDiff(output, '''\
321
336
    def test_diff_remove_files(self):
322
337
        tree1 = self.b.repository.revision_tree('rev-3')
323
338
        tree2 = self.b.repository.revision_tree('rev-4')
324
 
        output = self.get_diff(tree1, tree2)
 
339
        output = get_diff_as_string(tree1, tree2)
325
340
        # the file has the epoch time stamp for the tree in which
326
341
        # it doesn't exist.
327
342
        self.assertEqualDiff(output, '''\
338
353
        self.wt.rename_one('file1', 'file1b')
339
354
        old_tree = self.b.repository.revision_tree('rev-1')
340
355
        new_tree = self.b.repository.revision_tree('rev-4')
341
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
 
356
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
342
357
                            working_tree=self.wt)
343
358
        self.assertContainsRe(out, 'file1\t')
344
359
 
350
365
        self.wt.rename_one('file1', 'dir1/file1')
351
366
        old_tree = self.b.repository.revision_tree('rev-1')
352
367
        new_tree = self.b.repository.revision_tree('rev-4')
353
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
 
368
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
354
369
                            working_tree=self.wt)
355
370
        self.assertContainsRe(out, 'file1\t')
356
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
 
371
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
357
372
                            working_tree=self.wt)
358
373
        self.assertNotContainsRe(out, 'file1\t')
359
374
 
360
375
 
361
 
 
362
 
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
376
class TestShowDiffTrees(tests.TestCaseWithTransport):
363
377
    """Direct tests for show_diff_trees"""
364
378
 
365
379
    def test_modified_file(self):
370
384
        tree.commit('one', rev_id='rev-1')
371
385
 
372
386
        self.build_tree_contents([('tree/file', 'new contents\n')])
373
 
        diff = self.get_diff(tree.basis_tree(), tree)
374
 
        self.assertContainsRe(diff, "=== modified file 'file'\n")
375
 
        self.assertContainsRe(diff, '--- old/file\t')
376
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
377
 
        self.assertContainsRe(diff, '-contents\n'
378
 
                                    '\\+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')
379
393
 
380
394
    def test_modified_file_in_renamed_dir(self):
381
395
        """Test when a file is modified in a renamed directory."""
387
401
 
388
402
        tree.rename_one('dir', 'other')
389
403
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
390
 
        diff = self.get_diff(tree.basis_tree(), tree)
391
 
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
392
 
        self.assertContainsRe(diff, "=== modified file 'other/file'\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")
393
407
        # XXX: This is technically incorrect, because it used to be at another
394
408
        # location. What to do?
395
 
        self.assertContainsRe(diff, '--- old/dir/file\t')
396
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
397
 
        self.assertContainsRe(diff, '-contents\n'
398
 
                                    '\\+new contents\n')
 
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')
399
413
 
400
414
    def test_renamed_directory(self):
401
415
        """Test when only a directory is only renamed."""
406
420
        tree.commit('one', rev_id='rev-1')
407
421
 
408
422
        tree.rename_one('dir', 'newdir')
409
 
        diff = self.get_diff(tree.basis_tree(), tree)
 
423
        d = get_diff_as_string(tree.basis_tree(), tree)
410
424
        # Renaming a directory should be a single "you renamed this dir" even
411
425
        # when there are files inside.
412
 
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
 
426
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
413
427
 
414
428
    def test_renamed_file(self):
415
429
        """Test when a file is only renamed."""
419
433
        tree.commit('one', rev_id='rev-1')
420
434
 
421
435
        tree.rename_one('file', 'newname')
422
 
        diff = self.get_diff(tree.basis_tree(), tree)
423
 
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
436
        d = get_diff_as_string(tree.basis_tree(), tree)
 
437
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
424
438
        # We shouldn't have a --- or +++ line, because there is no content
425
439
        # change
426
 
        self.assertNotContainsRe(diff, '---')
 
440
        self.assertNotContainsRe(d, '---')
427
441
 
428
442
    def test_renamed_and_modified_file(self):
429
443
        """Test when a file is only renamed."""
434
448
 
435
449
        tree.rename_one('file', 'newname')
436
450
        self.build_tree_contents([('tree/newname', 'new contents\n')])
437
 
        diff = self.get_diff(tree.basis_tree(), tree)
438
 
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
439
 
        self.assertContainsRe(diff, '--- old/file\t')
440
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
441
 
        self.assertContainsRe(diff, '-contents\n'
442
 
                                    '\\+new contents\n')
443
 
 
444
 
 
445
 
class TestPatienceDiffLib(TestCase):
 
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'")
 
493
 
 
494
    def test_binary_unicode_filenames(self):
 
495
        """Test that contents of files are *not* encoded in UTF-8 when there
 
496
        is a binary file in the diff.
 
497
        """
 
498
        # See https://bugs.launchpad.net/bugs/110092.
 
499
        self.requireFeature(features.UnicodeFilenameFeature)
 
500
 
 
501
        # This bug isn't triggered with cStringIO.
 
502
        from StringIO import StringIO
 
503
        tree = self.make_branch_and_tree('tree')
 
504
        alpha, omega = u'\u03b1', u'\u03c9'
 
505
        alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')
 
506
        self.build_tree_contents(
 
507
            [('tree/' + alpha, chr(0)),
 
508
             ('tree/' + omega,
 
509
              ('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])
 
510
        tree.add([alpha], ['file-id'])
 
511
        tree.add([omega], ['file-id-2'])
 
512
        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))
446
780
 
447
781
    def test_unique_lcs(self):
448
 
        unique_lcs = bzrlib.patiencediff.unique_lcs
 
782
        unique_lcs = self._unique_lcs
449
783
        self.assertEquals(unique_lcs('', ''), [])
 
784
        self.assertEquals(unique_lcs('', 'a'), [])
 
785
        self.assertEquals(unique_lcs('a', ''), [])
450
786
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
451
787
        self.assertEquals(unique_lcs('a', 'b'), [])
452
788
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
453
789
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
454
790
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
455
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
 
791
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
456
792
                                                         (3,3), (4,4)])
457
793
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
458
794
 
459
795
    def test_recurse_matches(self):
460
796
        def test_one(a, b, matches):
461
797
            test_matches = []
462
 
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
463
 
                test_matches, 10)
 
798
            self._recurse_matches(
 
799
                a, b, 0, 0, len(a), len(b), test_matches, 10)
464
800
            self.assertEquals(test_matches, matches)
465
801
 
466
802
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
467
803
                 [(0, 0), (2, 2), (4, 4)])
468
804
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
469
805
                 [(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)])
470
811
 
471
 
        # recurse_matches doesn't match non-unique 
 
812
        # recurse_matches doesn't match non-unique
472
813
        # lines surrounded by bogus text.
473
814
        # The update has been done in patiencediff.SequenceMatcher instead
474
815
 
478
819
        # This is what it currently gives:
479
820
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
480
821
 
 
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
 
481
836
    def test_matching_blocks(self):
482
 
        def chk_blocks(a, b, expected_blocks):
483
 
            # difflib always adds a signature of the total
484
 
            # length, with no matching entries at the end
485
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
486
 
            blocks = s.get_matching_blocks()
487
 
            self.assertEquals((len(a), len(b), 0), blocks[-1])
488
 
            self.assertEquals(expected_blocks, blocks[:-1])
489
 
 
490
837
        # Some basic matching tests
491
 
        chk_blocks('', '', [])
492
 
        chk_blocks([], [], [])
493
 
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
494
 
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
495
 
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
496
 
        chk_blocks('eabce', 'abce', [(1, 0, 4)])
497
 
        chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
498
 
        chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
499
 
        chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
500
 
        # This may check too much, but it checks to see that 
 
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
501
850
        # a copied block stays attached to the previous section,
502
851
        # not the later one.
503
852
        # difflib would tend to grab the trailing longest match
504
853
        # which would make the diff not look right
505
 
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
506
 
                   [(0, 0, 6), (6, 11, 10)])
 
854
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
855
                              [(0, 0, 6), (6, 11, 10)])
507
856
 
508
857
        # make sure it supports passing in lists
509
 
        chk_blocks(
 
858
        self.assertDiffBlocks(
510
859
                   ['hello there\n',
511
860
                    'world\n',
512
861
                    'how are you today?\n'],
516
865
 
517
866
        # non unique lines surrounded by non-matching lines
518
867
        # won't be found
519
 
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
868
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
520
869
 
521
870
        # But they only need to be locally unique
522
 
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
871
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
523
872
 
524
873
        # non unique blocks won't be matched
525
 
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
874
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
526
875
 
527
876
        # but locally unique ones will
528
 
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
877
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
529
878
                                              (5,4,1), (7,5,2), (10,8,1)])
530
879
 
531
 
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
532
 
        chk_blocks('abbabbbb', 'cabbabbc', [])
533
 
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
 
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)])
534
907
 
535
908
    def test_opcodes(self):
536
909
        def chk_ops(a, b, expected_codes):
537
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
910
            s = self._PatienceSequenceMatcher(None, a, b)
538
911
            self.assertEquals(expected_codes, s.get_opcodes())
539
912
 
540
913
        chk_ops('', '', [])
541
914
        chk_ops([], [], [])
 
915
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
 
916
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
542
917
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
543
918
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
544
919
                                 ('replace', 3,4, 3,4)
577
952
                 ('delete', 1,2, 1,1),
578
953
                 ('equal',  2,3, 1,2),
579
954
                ])
580
 
        chk_ops('aBccDe', 'abccde', 
 
955
        chk_ops('aBccDe', 'abccde',
581
956
                [('equal',   0,1, 0,1),
582
957
                 ('replace', 1,5, 1,5),
583
958
                 ('equal',   5,6, 5,6),
584
959
                ])
585
 
        chk_ops('aBcDec', 'abcdec', 
 
960
        chk_ops('aBcDec', 'abcdec',
586
961
                [('equal',   0,1, 0,1),
587
962
                 ('replace', 1,2, 1,2),
588
963
                 ('equal',   2,3, 2,3),
589
964
                 ('replace', 3,4, 3,4),
590
965
                 ('equal',   4,6, 4,6),
591
966
                ])
592
 
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
 
967
        chk_ops('aBcdEcdFg', 'abcdecdfg',
593
968
                [('equal',   0,1, 0,1),
594
969
                 ('replace', 1,8, 1,8),
595
970
                 ('equal',   8,9, 8,9)
596
971
                ])
597
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
 
972
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
598
973
                [('equal',   0,1, 0,1),
599
974
                 ('replace', 1,2, 1,2),
600
975
                 ('equal',   2,4, 2,4),
606
981
                 ('equal',   10,11, 8,9)
607
982
                ])
608
983
 
 
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
 
609
1021
    def test_multiple_ranges(self):
610
1022
        # There was an earlier bug where we used a bad set of ranges,
611
1023
        # this triggers that specific bug, to make sure it doesn't regress
612
 
        def chk_blocks(a, b, expected_blocks):
613
 
            # difflib always adds a signature of the total
614
 
            # length, with no matching entries at the end
615
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
616
 
            blocks = s.get_matching_blocks()
617
 
            x = blocks.pop()
618
 
            self.assertEquals(x, (len(a), len(b), 0))
619
 
            self.assertEquals(expected_blocks, blocks)
620
 
 
621
 
        chk_blocks('abcdefghijklmnop'
622
 
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
623
 
                 , [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
624
 
 
625
 
        chk_blocks('ABCd efghIjk  L'
626
 
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
627
 
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
 
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)])
628
1031
 
629
1032
        # These are rot13 code snippets.
630
 
        chk_blocks('''\
 
1033
        self.assertDiffBlocks('''\
631
1034
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
632
1035
    """
633
1036
    gnxrf_netf = ['svyr*']
634
1037
    gnxrf_bcgvbaf = ['ab-erphefr']
635
 
  
 
1038
 
636
1039
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
637
1040
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
638
1041
        vs vf_dhvrg():
646
1049
'''.splitlines(True), '''\
647
1050
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
648
1051
 
649
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
 
1052
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
650
1053
    nqq gurz.
651
1054
    """
652
1055
    gnxrf_netf = ['svyr*']
679
1082
                 'how are you today?\n']
680
1083
        txt_b = ['hello there\n',
681
1084
                 'how are you today?\n']
682
 
        unified_diff = bzrlib.patiencediff.unified_diff
683
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
684
 
        self.assertEquals([ '---  \n',
685
 
                           '+++  \n',
 
1085
        unified_diff = patiencediff.unified_diff
 
1086
        psm = self._PatienceSequenceMatcher
 
1087
        self.assertEquals(['--- \n',
 
1088
                           '+++ \n',
686
1089
                           '@@ -1,3 +1,2 @@\n',
687
1090
                           ' hello there\n',
688
1091
                           '-world\n',
693
1096
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
694
1097
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
695
1098
        # This is the result with LongestCommonSubstring matching
696
 
        self.assertEquals(['---  \n',
697
 
                           '+++  \n',
 
1099
        self.assertEquals(['--- \n',
 
1100
                           '+++ \n',
698
1101
                           '@@ -1,6 +1,11 @@\n',
699
1102
                           ' a\n',
700
1103
                           ' b\n',
709
1112
                           ' f\n']
710
1113
                          , list(unified_diff(txt_a, txt_b)))
711
1114
        # And the patience diff
712
 
        self.assertEquals(['---  \n',
713
 
                           '+++  \n',
 
1115
        self.assertEquals(['--- \n',
 
1116
                           '+++ \n',
714
1117
                           '@@ -4,6 +4,11 @@\n',
715
1118
                           ' d\n',
716
1119
                           ' e\n',
727
1130
                          , list(unified_diff(txt_a, txt_b,
728
1131
                                 sequencematcher=psm)))
729
1132
 
730
 
 
731
 
class TestPatienceDiffLibFiles(TestCaseInTempDir):
 
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
732
1187
 
733
1188
    def test_patience_unified_diff_files(self):
734
1189
        txt_a = ['hello there\n',
736
1191
                 'how are you today?\n']
737
1192
        txt_b = ['hello there\n',
738
1193
                 'how are you today?\n']
739
 
        open('a1', 'wb').writelines(txt_a)
740
 
        open('b1', 'wb').writelines(txt_b)
 
1194
        with open('a1', 'wb') as f: f.writelines(txt_a)
 
1195
        with open('b1', 'wb') as f: f.writelines(txt_b)
741
1196
 
742
 
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
743
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
744
 
        self.assertEquals(['--- a1 \n',
745
 
                           '+++ b1 \n',
 
1197
        unified_diff_files = patiencediff.unified_diff_files
 
1198
        psm = self._PatienceSequenceMatcher
 
1199
        self.assertEquals(['--- a1\n',
 
1200
                           '+++ b1\n',
746
1201
                           '@@ -1,3 +1,2 @@\n',
747
1202
                           ' hello there\n',
748
1203
                           '-world\n',
753
1208
 
754
1209
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
755
1210
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
756
 
        open('a2', 'wb').writelines(txt_a)
757
 
        open('b2', 'wb').writelines(txt_b)
 
1211
        with open('a2', 'wb') as f: f.writelines(txt_a)
 
1212
        with open('b2', 'wb') as f: f.writelines(txt_b)
758
1213
 
759
1214
        # This is the result with LongestCommonSubstring matching
760
 
        self.assertEquals(['--- a2 \n',
761
 
                           '+++ b2 \n',
 
1215
        self.assertEquals(['--- a2\n',
 
1216
                           '+++ b2\n',
762
1217
                           '@@ -1,6 +1,11 @@\n',
763
1218
                           ' a\n',
764
1219
                           ' b\n',
774
1229
                          , list(unified_diff_files('a2', 'b2')))
775
1230
 
776
1231
        # And the patience diff
777
 
        self.assertEquals(['--- a2 \n',
778
 
                           '+++ b2 \n',
 
1232
        self.assertEquals(['--- a2\n',
 
1233
                           '+++ b2\n',
779
1234
                           '@@ -4,6 +4,11 @@\n',
780
1235
                           ' d\n',
781
1236
                           ' e\n',
791
1246
                          ]
792
1247
                          , list(unified_diff_files('a2', 'b2',
793
1248
                                 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)