← 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: Patch Queue Manager
  • Date: 2013-05-23 10:35:23 UTC
  • mfrom: (6574.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20130523103523-2wt6jmauja1n1vdt
(jameinel) Merge bzr/2.5 into trunk. (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005, 2006 Canonical Development 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
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
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
 
from tempfile import TemporaryFile
 
19
import subprocess
 
20
import sys
 
21
import tempfile
21
22
 
22
 
from bzrlib.diff import internal_diff, external_diff, show_diff_trees
23
 
from bzrlib.errors import BinaryFile, NoDiff
24
 
import bzrlib.patiencediff
25
 
from bzrlib.tests import (TestCase, TestCaseWithTransport,
26
 
                          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
    )
27
41
 
28
42
 
29
43
def udiff_lines(old, new, allow_binary=False):
30
44
    output = StringIO()
31
 
    internal_diff('old', old, 'new', new, output, allow_binary)
 
45
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
32
46
    output.seek(0, 0)
33
47
    return output.readlines()
34
48
 
38
52
        # StringIO has no fileno, so it tests a different codepath
39
53
        output = StringIO()
40
54
    else:
41
 
        output = TemporaryFile()
 
55
        output = tempfile.TemporaryFile()
42
56
    try:
43
 
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
44
 
    except NoDiff:
45
 
        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')
46
60
    output.seek(0, 0)
47
61
    lines = output.readlines()
48
62
    output.close()
49
63
    return lines
50
64
 
51
65
 
52
 
class TestDiff(TestCase):
 
66
class TestDiff(tests.TestCase):
53
67
 
54
68
    def test_add_nl(self):
55
69
        """diff generates a valid diff for patches that add a newline"""
91
105
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
92
106
 
93
107
    def test_binary_lines(self):
94
 
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
95
 
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
96
 
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
97
 
        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)
98
114
 
99
115
    def test_external_diff(self):
100
116
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
101
117
        self.check_patch(lines)
 
118
        self.assertEqual('\n', lines[-1])
102
119
 
103
120
    def test_external_diff_no_fileno(self):
104
121
        # Make sure that we can handle not having a fileno, even
107
124
                                     ['goo\n']*10000,
108
125
                                     use_stringio=True)
109
126
        self.check_patch(lines)
110
 
        
 
127
 
 
128
    def test_external_diff_binary_lang_c(self):
 
129
        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'])
 
136
 
 
137
    def test_no_external_diff(self):
 
138
        """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
 
111
146
    def test_internal_diff_default(self):
112
147
        # Default internal diff encoding is utf8
113
148
        output = StringIO()
114
 
        internal_diff(u'old_\xb5', ['old_text\n'],
115
 
                    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)
116
151
        lines = output.getvalue().splitlines(True)
117
152
        self.check_patch(lines)
118
153
        self.assertEquals(['--- old_\xc2\xb5\n',
126
161
 
127
162
    def test_internal_diff_utf8(self):
128
163
        output = StringIO()
129
 
        internal_diff(u'old_\xb5', ['old_text\n'],
130
 
                    u'new_\xe5', ['new_text\n'], output,
131
 
                    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')
132
167
        lines = output.getvalue().splitlines(True)
133
168
        self.check_patch(lines)
134
169
        self.assertEquals(['--- old_\xc2\xb5\n',
142
177
 
143
178
    def test_internal_diff_iso_8859_1(self):
144
179
        output = StringIO()
145
 
        internal_diff(u'old_\xb5', ['old_text\n'],
146
 
                    u'new_\xe5', ['new_text\n'], output,
147
 
                    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')
148
183
        lines = output.getvalue().splitlines(True)
149
184
        self.check_patch(lines)
150
185
        self.assertEquals(['--- old_\xb5\n',
156
191
                          ]
157
192
                          , lines)
158
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
 
159
206
    def test_internal_diff_returns_bytes(self):
160
207
        import StringIO
161
208
        output = StringIO.StringIO()
162
 
        internal_diff(u'old_\xb5', ['old_text\n'],
163
 
                    u'new_\xe5', ['new_text\n'], output)
164
 
        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,
165
212
            'internal_diff should return bytestrings')
166
213
 
167
 
 
168
 
class TestDiffDates(TestCaseWithTransport):
 
214
    def test_internal_diff_default_context(self):
 
215
        output = StringIO()
 
216
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
217
                           'same_text\n','same_text\n','old_text\n'],
 
218
                           'new', ['same_text\n','same_text\n','same_text\n',
 
219
                           'same_text\n','same_text\n','new_text\n'], output)
 
220
        lines = output.getvalue().splitlines(True)
 
221
        self.check_patch(lines)
 
222
        self.assertEquals(['--- old\n',
 
223
                           '+++ new\n',
 
224
                           '@@ -3,4 +3,4 @@\n',
 
225
                           ' same_text\n',
 
226
                           ' same_text\n',
 
227
                           ' same_text\n',
 
228
                           '-old_text\n',
 
229
                           '+new_text\n',
 
230
                           '\n',
 
231
                          ]
 
232
                          , lines)
 
233
 
 
234
    def test_internal_diff_no_context(self):
 
235
        output = StringIO()
 
236
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
237
                           'same_text\n','same_text\n','old_text\n'],
 
238
                           'new', ['same_text\n','same_text\n','same_text\n',
 
239
                           'same_text\n','same_text\n','new_text\n'], output,
 
240
                           context_lines=0)
 
241
        lines = output.getvalue().splitlines(True)
 
242
        self.check_patch(lines)
 
243
        self.assertEquals(['--- old\n',
 
244
                           '+++ new\n',
 
245
                           '@@ -6,1 +6,1 @@\n',
 
246
                           '-old_text\n',
 
247
                           '+new_text\n',
 
248
                           '\n',
 
249
                          ]
 
250
                          , lines)
 
251
 
 
252
    def test_internal_diff_more_context(self):
 
253
        output = StringIO()
 
254
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
255
                           'same_text\n','same_text\n','old_text\n'],
 
256
                           'new', ['same_text\n','same_text\n','same_text\n',
 
257
                           'same_text\n','same_text\n','new_text\n'], output,
 
258
                           context_lines=4)
 
259
        lines = output.getvalue().splitlines(True)
 
260
        self.check_patch(lines)
 
261
        self.assertEquals(['--- old\n',
 
262
                           '+++ new\n',
 
263
                           '@@ -2,5 +2,5 @@\n',
 
264
                           ' same_text\n',
 
265
                           ' same_text\n',
 
266
                           ' same_text\n',
 
267
                           ' same_text\n',
 
268
                           '-old_text\n',
 
269
                           '+new_text\n',
 
270
                           '\n',
 
271
                          ]
 
272
                          , lines)
 
273
 
 
274
 
 
275
 
 
276
 
 
277
 
 
278
class TestDiffFiles(tests.TestCaseInTempDir):
 
279
 
 
280
    def test_external_diff_binary(self):
 
281
        """The output when using external diff should use diff's i18n error"""
 
282
        # Make sure external_diff doesn't fail in the current LANG
 
283
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
284
 
 
285
        cmd = ['diff', '-u', '--binary', 'old', 'new']
 
286
        with open('old', 'wb') as f: f.write('\x00foobar\n')
 
287
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
 
288
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
 
289
                                     stdin=subprocess.PIPE)
 
290
        out, err = pipe.communicate()
 
291
        # Diff returns '2' on Binary files.
 
292
        self.assertEqual(2, pipe.returncode)
 
293
        # We should output whatever diff tells us, plus a trailing newline
 
294
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
 
295
 
 
296
 
 
297
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
 
298
    output = StringIO()
 
299
    if working_tree is not None:
 
300
        extra_trees = (working_tree,)
 
301
    else:
 
302
        extra_trees = ()
 
303
    diff.show_diff_trees(tree1, tree2, output,
 
304
        specific_files=specific_files,
 
305
        extra_trees=extra_trees, old_label='old/',
 
306
        new_label='new/')
 
307
    return output.getvalue()
 
308
 
 
309
 
 
310
class TestDiffDates(tests.TestCaseWithTransport):
169
311
 
170
312
    def setUp(self):
171
313
        super(TestDiffDates, self).setUp()
205
347
        # set the date stamps for files in the working tree to known values
206
348
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
207
349
 
208
 
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
209
 
        output = StringIO()
210
 
        if working_tree is not None:
211
 
            extra_trees = (working_tree,)
212
 
        else:
213
 
            extra_trees = ()
214
 
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
215
 
                        extra_trees=extra_trees, old_label='old/', 
216
 
                        new_label='new/')
217
 
        return output.getvalue()
218
 
 
219
350
    def test_diff_rev_tree_working_tree(self):
220
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
351
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
221
352
        # note that the date for old/file1 is from rev 2 rather than from
222
353
        # the basis revision (rev 4)
223
354
        self.assertEqualDiff(output, '''\
233
364
    def test_diff_rev_tree_rev_tree(self):
234
365
        tree1 = self.b.repository.revision_tree('rev-2')
235
366
        tree2 = self.b.repository.revision_tree('rev-3')
236
 
        output = self.get_diff(tree1, tree2)
 
367
        output = get_diff_as_string(tree1, tree2)
237
368
        self.assertEqualDiff(output, '''\
238
369
=== modified file 'file2'
239
370
--- old/file2\t2006-04-01 00:00:00 +0000
243
374
+file2 contents at rev 3
244
375
 
245
376
''')
246
 
        
 
377
 
247
378
    def test_diff_add_files(self):
248
 
        tree1 = self.b.repository.revision_tree(None)
 
379
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
249
380
        tree2 = self.b.repository.revision_tree('rev-1')
250
 
        output = self.get_diff(tree1, tree2)
 
381
        output = get_diff_as_string(tree1, tree2)
251
382
        # the files have the epoch time stamp for the tree in which
252
383
        # they don't exist.
253
384
        self.assertEqualDiff(output, '''\
268
399
    def test_diff_remove_files(self):
269
400
        tree1 = self.b.repository.revision_tree('rev-3')
270
401
        tree2 = self.b.repository.revision_tree('rev-4')
271
 
        output = self.get_diff(tree1, tree2)
 
402
        output = get_diff_as_string(tree1, tree2)
272
403
        # the file has the epoch time stamp for the tree in which
273
404
        # it doesn't exist.
274
405
        self.assertEqualDiff(output, '''\
285
416
        self.wt.rename_one('file1', 'file1b')
286
417
        old_tree = self.b.repository.revision_tree('rev-1')
287
418
        new_tree = self.b.repository.revision_tree('rev-4')
288
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
 
419
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
289
420
                            working_tree=self.wt)
290
421
        self.assertContainsRe(out, 'file1\t')
291
422
 
297
428
        self.wt.rename_one('file1', 'dir1/file1')
298
429
        old_tree = self.b.repository.revision_tree('rev-1')
299
430
        new_tree = self.b.repository.revision_tree('rev-4')
300
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
 
431
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
301
432
                            working_tree=self.wt)
302
433
        self.assertContainsRe(out, 'file1\t')
303
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
 
434
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
304
435
                            working_tree=self.wt)
305
436
        self.assertNotContainsRe(out, 'file1\t')
306
437
 
307
 
class TestPatienceDiffLib(TestCase):
 
438
 
 
439
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
440
    """Direct tests for show_diff_trees"""
 
441
 
 
442
    def test_modified_file(self):
 
443
        """Test when a file is modified."""
 
444
        tree = self.make_branch_and_tree('tree')
 
445
        self.build_tree_contents([('tree/file', 'contents\n')])
 
446
        tree.add(['file'], ['file-id'])
 
447
        tree.commit('one', rev_id='rev-1')
 
448
 
 
449
        self.build_tree_contents([('tree/file', 'new contents\n')])
 
450
        d = get_diff_as_string(tree.basis_tree(), tree)
 
451
        self.assertContainsRe(d, "=== modified file 'file'\n")
 
452
        self.assertContainsRe(d, '--- old/file\t')
 
453
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
 
454
        self.assertContainsRe(d, '-contents\n'
 
455
                                 '\\+new contents\n')
 
456
 
 
457
    def test_modified_file_in_renamed_dir(self):
 
458
        """Test when a file is modified in a renamed directory."""
 
459
        tree = self.make_branch_and_tree('tree')
 
460
        self.build_tree(['tree/dir/'])
 
461
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
 
462
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
463
        tree.commit('one', rev_id='rev-1')
 
464
 
 
465
        tree.rename_one('dir', 'other')
 
466
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
 
467
        d = get_diff_as_string(tree.basis_tree(), tree)
 
468
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
 
469
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
470
        # XXX: This is technically incorrect, because it used to be at another
 
471
        # location. What to do?
 
472
        self.assertContainsRe(d, '--- old/dir/file\t')
 
473
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
 
474
        self.assertContainsRe(d, '-contents\n'
 
475
                                 '\\+new contents\n')
 
476
 
 
477
    def test_renamed_directory(self):
 
478
        """Test when only a directory is only renamed."""
 
479
        tree = self.make_branch_and_tree('tree')
 
480
        self.build_tree(['tree/dir/'])
 
481
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
 
482
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
483
        tree.commit('one', rev_id='rev-1')
 
484
 
 
485
        tree.rename_one('dir', 'newdir')
 
486
        d = get_diff_as_string(tree.basis_tree(), tree)
 
487
        # Renaming a directory should be a single "you renamed this dir" even
 
488
        # when there are files inside.
 
489
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
490
 
 
491
    def test_renamed_file(self):
 
492
        """Test when a file is only renamed."""
 
493
        tree = self.make_branch_and_tree('tree')
 
494
        self.build_tree_contents([('tree/file', 'contents\n')])
 
495
        tree.add(['file'], ['file-id'])
 
496
        tree.commit('one', rev_id='rev-1')
 
497
 
 
498
        tree.rename_one('file', 'newname')
 
499
        d = get_diff_as_string(tree.basis_tree(), tree)
 
500
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
501
        # We shouldn't have a --- or +++ line, because there is no content
 
502
        # change
 
503
        self.assertNotContainsRe(d, '---')
 
504
 
 
505
    def test_renamed_and_modified_file(self):
 
506
        """Test when a file is only renamed."""
 
507
        tree = self.make_branch_and_tree('tree')
 
508
        self.build_tree_contents([('tree/file', 'contents\n')])
 
509
        tree.add(['file'], ['file-id'])
 
510
        tree.commit('one', rev_id='rev-1')
 
511
 
 
512
        tree.rename_one('file', 'newname')
 
513
        self.build_tree_contents([('tree/newname', 'new contents\n')])
 
514
        d = get_diff_as_string(tree.basis_tree(), tree)
 
515
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
516
        self.assertContainsRe(d, '--- old/file\t')
 
517
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
 
518
        self.assertContainsRe(d, '-contents\n'
 
519
                                 '\\+new contents\n')
 
520
 
 
521
 
 
522
    def test_internal_diff_exec_property(self):
 
523
        tree = self.make_branch_and_tree('tree')
 
524
 
 
525
        tt = transform.TreeTransform(tree)
 
526
        tt.new_file('a', tt.root, 'contents\n', 'a-id', True)
 
527
        tt.new_file('b', tt.root, 'contents\n', 'b-id', False)
 
528
        tt.new_file('c', tt.root, 'contents\n', 'c-id', True)
 
529
        tt.new_file('d', tt.root, 'contents\n', 'd-id', False)
 
530
        tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)
 
531
        tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)
 
532
        tt.apply()
 
533
        tree.commit('one', rev_id='rev-1')
 
534
 
 
535
        tt = transform.TreeTransform(tree)
 
536
        tt.set_executability(False, tt.trans_id_file_id('a-id'))
 
537
        tt.set_executability(True, tt.trans_id_file_id('b-id'))
 
538
        tt.set_executability(False, tt.trans_id_file_id('c-id'))
 
539
        tt.set_executability(True, tt.trans_id_file_id('d-id'))
 
540
        tt.apply()
 
541
        tree.rename_one('c', 'new-c')
 
542
        tree.rename_one('d', 'new-d')
 
543
 
 
544
        d = get_diff_as_string(tree.basis_tree(), tree)
 
545
 
 
546
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
 
547
                                  ".*\+x to -x.*\)")
 
548
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
 
549
                                  ".*-x to \+x.*\)")
 
550
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
 
551
                                  ".*\+x to -x.*\)")
 
552
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
 
553
                                  ".*-x to \+x.*\)")
 
554
        self.assertNotContainsRe(d, r"file 'e'")
 
555
        self.assertNotContainsRe(d, r"file 'f'")
 
556
 
 
557
    def test_binary_unicode_filenames(self):
 
558
        """Test that contents of files are *not* encoded in UTF-8 when there
 
559
        is a binary file in the diff.
 
560
        """
 
561
        # See https://bugs.launchpad.net/bugs/110092.
 
562
        self.requireFeature(features.UnicodeFilenameFeature)
 
563
 
 
564
        # This bug isn't triggered with cStringIO.
 
565
        from StringIO import StringIO
 
566
        tree = self.make_branch_and_tree('tree')
 
567
        alpha, omega = u'\u03b1', u'\u03c9'
 
568
        alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')
 
569
        self.build_tree_contents(
 
570
            [('tree/' + alpha, chr(0)),
 
571
             ('tree/' + omega,
 
572
              ('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])
 
573
        tree.add([alpha], ['file-id'])
 
574
        tree.add([omega], ['file-id-2'])
 
575
        diff_content = StringIO()
 
576
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
 
577
        d = diff_content.getvalue()
 
578
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
 
579
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
 
580
                              % (alpha_utf8, alpha_utf8))
 
581
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
 
582
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
 
583
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
 
584
 
 
585
    def test_unicode_filename(self):
 
586
        """Test when the filename are unicode."""
 
587
        self.requireFeature(features.UnicodeFilenameFeature)
 
588
 
 
589
        alpha, omega = u'\u03b1', u'\u03c9'
 
590
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
 
591
 
 
592
        tree = self.make_branch_and_tree('tree')
 
593
        self.build_tree_contents([('tree/ren_'+alpha, 'contents\n')])
 
594
        tree.add(['ren_'+alpha], ['file-id-2'])
 
595
        self.build_tree_contents([('tree/del_'+alpha, 'contents\n')])
 
596
        tree.add(['del_'+alpha], ['file-id-3'])
 
597
        self.build_tree_contents([('tree/mod_'+alpha, 'contents\n')])
 
598
        tree.add(['mod_'+alpha], ['file-id-4'])
 
599
 
 
600
        tree.commit('one', rev_id='rev-1')
 
601
 
 
602
        tree.rename_one('ren_'+alpha, 'ren_'+omega)
 
603
        tree.remove('del_'+alpha)
 
604
        self.build_tree_contents([('tree/add_'+alpha, 'contents\n')])
 
605
        tree.add(['add_'+alpha], ['file-id'])
 
606
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
 
607
 
 
608
        d = get_diff_as_string(tree.basis_tree(), tree)
 
609
        self.assertContainsRe(d,
 
610
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
 
611
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
 
612
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
 
613
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
 
614
 
 
615
    def test_unicode_filename_path_encoding(self):
 
616
        """Test for bug #382699: unicode filenames on Windows should be shown
 
617
        in user encoding.
 
618
        """
 
619
        self.requireFeature(features.UnicodeFilenameFeature)
 
620
        # The word 'test' in Russian
 
621
        _russian_test = u'\u0422\u0435\u0441\u0442'
 
622
        directory = _russian_test + u'/'
 
623
        test_txt = _russian_test + u'.txt'
 
624
        u1234 = u'\u1234.txt'
 
625
 
 
626
        tree = self.make_branch_and_tree('.')
 
627
        self.build_tree_contents([
 
628
            (test_txt, 'foo\n'),
 
629
            (u1234, 'foo\n'),
 
630
            (directory, None),
 
631
            ])
 
632
        tree.add([test_txt, u1234, directory])
 
633
 
 
634
        sio = StringIO()
 
635
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
 
636
            path_encoding='cp1251')
 
637
 
 
638
        output = subst_dates(sio.getvalue())
 
639
        shouldbe = ('''\
 
640
=== added directory '%(directory)s'
 
641
=== added file '%(test_txt)s'
 
642
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
643
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
644
@@ -0,0 +1,1 @@
 
645
+foo
 
646
 
 
647
=== added file '?.txt'
 
648
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
649
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
650
@@ -0,0 +1,1 @@
 
651
+foo
 
652
 
 
653
''' % {'directory': _russian_test.encode('cp1251'),
 
654
       'test_txt': test_txt.encode('cp1251'),
 
655
      })
 
656
        self.assertEqualDiff(output, shouldbe)
 
657
 
 
658
 
 
659
class DiffWasIs(diff.DiffPath):
 
660
 
 
661
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
 
662
        self.to_file.write('was: ')
 
663
        self.to_file.write(self.old_tree.get_file(file_id).read())
 
664
        self.to_file.write('is: ')
 
665
        self.to_file.write(self.new_tree.get_file(file_id).read())
 
666
        pass
 
667
 
 
668
 
 
669
class TestDiffTree(tests.TestCaseWithTransport):
 
670
 
 
671
    def setUp(self):
 
672
        super(TestDiffTree, self).setUp()
 
673
        self.old_tree = self.make_branch_and_tree('old-tree')
 
674
        self.old_tree.lock_write()
 
675
        self.addCleanup(self.old_tree.unlock)
 
676
        self.new_tree = self.make_branch_and_tree('new-tree')
 
677
        self.new_tree.lock_write()
 
678
        self.addCleanup(self.new_tree.unlock)
 
679
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
680
 
 
681
    def test_diff_text(self):
 
682
        self.build_tree_contents([('old-tree/olddir/',),
 
683
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
684
        self.old_tree.add('olddir')
 
685
        self.old_tree.add('olddir/oldfile', 'file-id')
 
686
        self.build_tree_contents([('new-tree/newdir/',),
 
687
                                  ('new-tree/newdir/newfile', 'new\n')])
 
688
        self.new_tree.add('newdir')
 
689
        self.new_tree.add('newdir/newfile', 'file-id')
 
690
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
691
        differ.diff_text('file-id', None, 'old label', 'new label')
 
692
        self.assertEqual(
 
693
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
 
694
            differ.to_file.getvalue())
 
695
        differ.to_file.seek(0)
 
696
        differ.diff_text(None, 'file-id', 'old label', 'new label')
 
697
        self.assertEqual(
 
698
            '--- old label\n+++ new label\n@@ -0,0 +1,1 @@\n+new\n\n',
 
699
            differ.to_file.getvalue())
 
700
        differ.to_file.seek(0)
 
701
        differ.diff_text('file-id', 'file-id', 'old label', 'new label')
 
702
        self.assertEqual(
 
703
            '--- old label\n+++ new label\n@@ -1,1 +1,1 @@\n-old\n+new\n\n',
 
704
            differ.to_file.getvalue())
 
705
 
 
706
    def test_diff_deletion(self):
 
707
        self.build_tree_contents([('old-tree/file', 'contents'),
 
708
                                  ('new-tree/file', 'contents')])
 
709
        self.old_tree.add('file', 'file-id')
 
710
        self.new_tree.add('file', 'file-id')
 
711
        os.unlink('new-tree/file')
 
712
        self.differ.show_diff(None)
 
713
        self.assertContainsRe(self.differ.to_file.getvalue(), '-contents')
 
714
 
 
715
    def test_diff_creation(self):
 
716
        self.build_tree_contents([('old-tree/file', 'contents'),
 
717
                                  ('new-tree/file', 'contents')])
 
718
        self.old_tree.add('file', 'file-id')
 
719
        self.new_tree.add('file', 'file-id')
 
720
        os.unlink('old-tree/file')
 
721
        self.differ.show_diff(None)
 
722
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
 
723
 
 
724
    def test_diff_symlink(self):
 
725
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
726
        differ.diff_symlink('old target', None)
 
727
        self.assertEqual("=== target was 'old target'\n",
 
728
                         differ.to_file.getvalue())
 
729
 
 
730
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
731
        differ.diff_symlink(None, 'new target')
 
732
        self.assertEqual("=== target is 'new target'\n",
 
733
                         differ.to_file.getvalue())
 
734
 
 
735
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
736
        differ.diff_symlink('old target', 'new target')
 
737
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
 
738
                         differ.to_file.getvalue())
 
739
 
 
740
    def test_diff(self):
 
741
        self.build_tree_contents([('old-tree/olddir/',),
 
742
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
743
        self.old_tree.add('olddir')
 
744
        self.old_tree.add('olddir/oldfile', 'file-id')
 
745
        self.build_tree_contents([('new-tree/newdir/',),
 
746
                                  ('new-tree/newdir/newfile', 'new\n')])
 
747
        self.new_tree.add('newdir')
 
748
        self.new_tree.add('newdir/newfile', 'file-id')
 
749
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
750
        self.assertContainsRe(
 
751
            self.differ.to_file.getvalue(),
 
752
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
753
             ' \@\@\n-old\n\+new\n\n')
 
754
 
 
755
    def test_diff_kind_change(self):
 
756
        self.requireFeature(features.SymlinkFeature)
 
757
        self.build_tree_contents([('old-tree/olddir/',),
 
758
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
759
        self.old_tree.add('olddir')
 
760
        self.old_tree.add('olddir/oldfile', 'file-id')
 
761
        self.build_tree(['new-tree/newdir/'])
 
762
        os.symlink('new', 'new-tree/newdir/newfile')
 
763
        self.new_tree.add('newdir')
 
764
        self.new_tree.add('newdir/newfile', 'file-id')
 
765
        self.differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
766
        self.assertContainsRe(
 
767
            self.differ.to_file.getvalue(),
 
768
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
 
769
             ' \@\@\n-old\n\n')
 
770
        self.assertContainsRe(self.differ.to_file.getvalue(),
 
771
                              "=== target is u'new'\n")
 
772
 
 
773
    def test_diff_directory(self):
 
774
        self.build_tree(['new-tree/new-dir/'])
 
775
        self.new_tree.add('new-dir', 'new-dir-id')
 
776
        self.differ.diff('new-dir-id', None, 'new-dir')
 
777
        self.assertEqual(self.differ.to_file.getvalue(), '')
 
778
 
 
779
    def create_old_new(self):
 
780
        self.build_tree_contents([('old-tree/olddir/',),
 
781
                                  ('old-tree/olddir/oldfile', 'old\n')])
 
782
        self.old_tree.add('olddir')
 
783
        self.old_tree.add('olddir/oldfile', 'file-id')
 
784
        self.build_tree_contents([('new-tree/newdir/',),
 
785
                                  ('new-tree/newdir/newfile', 'new\n')])
 
786
        self.new_tree.add('newdir')
 
787
        self.new_tree.add('newdir/newfile', 'file-id')
 
788
 
 
789
    def test_register_diff(self):
 
790
        self.create_old_new()
 
791
        old_diff_factories = diff.DiffTree.diff_factories
 
792
        diff.DiffTree.diff_factories=old_diff_factories[:]
 
793
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
794
        try:
 
795
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
796
        finally:
 
797
            diff.DiffTree.diff_factories = old_diff_factories
 
798
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
799
        self.assertNotContainsRe(
 
800
            differ.to_file.getvalue(),
 
801
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
802
             ' \@\@\n-old\n\+new\n\n')
 
803
        self.assertContainsRe(differ.to_file.getvalue(),
 
804
                              'was: old\nis: new\n')
 
805
 
 
806
    def test_extra_factories(self):
 
807
        self.create_old_new()
 
808
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
 
809
                               extra_factories=[DiffWasIs.from_diff_tree])
 
810
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
 
811
        self.assertNotContainsRe(
 
812
            differ.to_file.getvalue(),
 
813
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+1,1'
 
814
             ' \@\@\n-old\n\+new\n\n')
 
815
        self.assertContainsRe(differ.to_file.getvalue(),
 
816
                              'was: old\nis: new\n')
 
817
 
 
818
    def test_alphabetical_order(self):
 
819
        self.build_tree(['new-tree/a-file'])
 
820
        self.new_tree.add('a-file')
 
821
        self.build_tree(['old-tree/b-file'])
 
822
        self.old_tree.add('b-file')
 
823
        self.differ.show_diff(None)
 
824
        self.assertContainsRe(self.differ.to_file.getvalue(),
 
825
            '.*a-file(.|\n)*b-file')
 
826
 
 
827
 
 
828
class TestPatienceDiffLib(tests.TestCase):
 
829
 
 
830
    def setUp(self):
 
831
        super(TestPatienceDiffLib, self).setUp()
 
832
        self._unique_lcs = _patiencediff_py.unique_lcs_py
 
833
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
834
        self._PatienceSequenceMatcher = \
 
835
            _patiencediff_py.PatienceSequenceMatcher_py
 
836
 
 
837
    def test_diff_unicode_string(self):
 
838
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
 
839
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
 
840
        sm = self._PatienceSequenceMatcher(None, a, b)
 
841
        mb = sm.get_matching_blocks()
 
842
        self.assertEquals(35, len(mb))
308
843
 
309
844
    def test_unique_lcs(self):
310
 
        unique_lcs = bzrlib.patiencediff.unique_lcs
 
845
        unique_lcs = self._unique_lcs
311
846
        self.assertEquals(unique_lcs('', ''), [])
 
847
        self.assertEquals(unique_lcs('', 'a'), [])
 
848
        self.assertEquals(unique_lcs('a', ''), [])
312
849
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
313
850
        self.assertEquals(unique_lcs('a', 'b'), [])
314
851
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
315
852
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
316
853
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
317
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
 
854
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
318
855
                                                         (3,3), (4,4)])
319
856
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
320
857
 
321
858
    def test_recurse_matches(self):
322
859
        def test_one(a, b, matches):
323
860
            test_matches = []
324
 
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
325
 
                test_matches, 10)
 
861
            self._recurse_matches(
 
862
                a, b, 0, 0, len(a), len(b), test_matches, 10)
326
863
            self.assertEquals(test_matches, matches)
327
864
 
328
865
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
329
866
                 [(0, 0), (2, 2), (4, 4)])
330
867
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
331
868
                 [(0, 0), (2, 1), (4, 2)])
 
869
        # Even though 'bc' is not unique globally, and is surrounded by
 
870
        # non-matching lines, we should still match, because they are locally
 
871
        # unique
 
872
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
 
873
                                          (4, 6), (5, 7), (6, 8)])
332
874
 
333
 
        # recurse_matches doesn't match non-unique 
 
875
        # recurse_matches doesn't match non-unique
334
876
        # lines surrounded by bogus text.
335
877
        # The update has been done in patiencediff.SequenceMatcher instead
336
878
 
340
882
        # This is what it currently gives:
341
883
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
342
884
 
 
885
    def assertDiffBlocks(self, a, b, expected_blocks):
 
886
        """Check that the sequence matcher returns the correct blocks.
 
887
 
 
888
        :param a: A sequence to match
 
889
        :param b: Another sequence to match
 
890
        :param expected_blocks: The expected output, not including the final
 
891
            matching block (len(a), len(b), 0)
 
892
        """
 
893
        matcher = self._PatienceSequenceMatcher(None, a, b)
 
894
        blocks = matcher.get_matching_blocks()
 
895
        last = blocks.pop()
 
896
        self.assertEqual((len(a), len(b), 0), last)
 
897
        self.assertEqual(expected_blocks, blocks)
 
898
 
343
899
    def test_matching_blocks(self):
344
 
        def chk_blocks(a, b, expected_blocks):
345
 
            # difflib always adds a signature of the total
346
 
            # length, with no matching entries at the end
347
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
348
 
            blocks = s.get_matching_blocks()
349
 
            self.assertEquals((len(a), len(b), 0), blocks[-1])
350
 
            self.assertEquals(expected_blocks, blocks[:-1])
351
 
 
352
900
        # Some basic matching tests
353
 
        chk_blocks('', '', [])
354
 
        chk_blocks([], [], [])
355
 
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
356
 
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
357
 
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
358
 
        chk_blocks('eabce', 'abce', [(1, 0, 4)])
359
 
        chk_blocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
360
 
        chk_blocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
361
 
        chk_blocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
362
 
        # This may check too much, but it checks to see that 
 
901
        self.assertDiffBlocks('', '', [])
 
902
        self.assertDiffBlocks([], [], [])
 
903
        self.assertDiffBlocks('abc', '', [])
 
904
        self.assertDiffBlocks('', 'abc', [])
 
905
        self.assertDiffBlocks('abcd', 'abcd', [(0, 0, 4)])
 
906
        self.assertDiffBlocks('abcd', 'abce', [(0, 0, 3)])
 
907
        self.assertDiffBlocks('eabc', 'abce', [(1, 0, 3)])
 
908
        self.assertDiffBlocks('eabce', 'abce', [(1, 0, 4)])
 
909
        self.assertDiffBlocks('abcde', 'abXde', [(0, 0, 2), (3, 3, 2)])
 
910
        self.assertDiffBlocks('abcde', 'abXYZde', [(0, 0, 2), (3, 5, 2)])
 
911
        self.assertDiffBlocks('abde', 'abXYZde', [(0, 0, 2), (2, 5, 2)])
 
912
        # This may check too much, but it checks to see that
363
913
        # a copied block stays attached to the previous section,
364
914
        # not the later one.
365
915
        # difflib would tend to grab the trailing longest match
366
916
        # which would make the diff not look right
367
 
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
368
 
                   [(0, 0, 6), (6, 11, 10)])
 
917
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
918
                              [(0, 0, 6), (6, 11, 10)])
369
919
 
370
920
        # make sure it supports passing in lists
371
 
        chk_blocks(
 
921
        self.assertDiffBlocks(
372
922
                   ['hello there\n',
373
923
                    'world\n',
374
924
                    'how are you today?\n'],
378
928
 
379
929
        # non unique lines surrounded by non-matching lines
380
930
        # won't be found
381
 
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
931
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
382
932
 
383
933
        # But they only need to be locally unique
384
 
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
934
        self.assertDiffBlocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
385
935
 
386
936
        # non unique blocks won't be matched
387
 
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
937
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
388
938
 
389
939
        # but locally unique ones will
390
 
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
940
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
391
941
                                              (5,4,1), (7,5,2), (10,8,1)])
392
942
 
393
 
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
394
 
        chk_blocks('abbabbbb', 'cabbabbc', [])
395
 
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
 
943
        self.assertDiffBlocks('abbabbXd', 'cabbabxd', [(7,7,1)])
 
944
        self.assertDiffBlocks('abbabbbb', 'cabbabbc', [])
 
945
        self.assertDiffBlocks('bbbbbbbb', 'cbbbbbbc', [])
 
946
 
 
947
    def test_matching_blocks_tuples(self):
 
948
        # Some basic matching tests
 
949
        self.assertDiffBlocks([], [], [])
 
950
        self.assertDiffBlocks([('a',), ('b',), ('c,')], [], [])
 
951
        self.assertDiffBlocks([], [('a',), ('b',), ('c,')], [])
 
952
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
 
953
                              [('a',), ('b',), ('c,')],
 
954
                              [(0, 0, 3)])
 
955
        self.assertDiffBlocks([('a',), ('b',), ('c,')],
 
956
                              [('a',), ('b',), ('d,')],
 
957
                              [(0, 0, 2)])
 
958
        self.assertDiffBlocks([('d',), ('b',), ('c,')],
 
959
                              [('a',), ('b',), ('c,')],
 
960
                              [(1, 1, 2)])
 
961
        self.assertDiffBlocks([('d',), ('a',), ('b',), ('c,')],
 
962
                              [('a',), ('b',), ('c,')],
 
963
                              [(1, 0, 3)])
 
964
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
 
965
                              [('a', 'b'), ('c', 'X'), ('e', 'f')],
 
966
                              [(0, 0, 1), (2, 2, 1)])
 
967
        self.assertDiffBlocks([('a', 'b'), ('c', 'd'), ('e', 'f')],
 
968
                              [('a', 'b'), ('c', 'dX'), ('e', 'f')],
 
969
                              [(0, 0, 1), (2, 2, 1)])
396
970
 
397
971
    def test_opcodes(self):
398
972
        def chk_ops(a, b, expected_codes):
399
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
973
            s = self._PatienceSequenceMatcher(None, a, b)
400
974
            self.assertEquals(expected_codes, s.get_opcodes())
401
975
 
402
976
        chk_ops('', '', [])
403
977
        chk_ops([], [], [])
 
978
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
 
979
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
404
980
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
405
981
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
406
982
                                 ('replace', 3,4, 3,4)
439
1015
                 ('delete', 1,2, 1,1),
440
1016
                 ('equal',  2,3, 1,2),
441
1017
                ])
442
 
        chk_ops('aBccDe', 'abccde', 
 
1018
        chk_ops('aBccDe', 'abccde',
443
1019
                [('equal',   0,1, 0,1),
444
1020
                 ('replace', 1,5, 1,5),
445
1021
                 ('equal',   5,6, 5,6),
446
1022
                ])
447
 
        chk_ops('aBcDec', 'abcdec', 
 
1023
        chk_ops('aBcDec', 'abcdec',
448
1024
                [('equal',   0,1, 0,1),
449
1025
                 ('replace', 1,2, 1,2),
450
1026
                 ('equal',   2,3, 2,3),
451
1027
                 ('replace', 3,4, 3,4),
452
1028
                 ('equal',   4,6, 4,6),
453
1029
                ])
454
 
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
 
1030
        chk_ops('aBcdEcdFg', 'abcdecdfg',
455
1031
                [('equal',   0,1, 0,1),
456
1032
                 ('replace', 1,8, 1,8),
457
1033
                 ('equal',   8,9, 8,9)
458
1034
                ])
459
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
 
1035
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
460
1036
                [('equal',   0,1, 0,1),
461
1037
                 ('replace', 1,2, 1,2),
462
1038
                 ('equal',   2,4, 2,4),
468
1044
                 ('equal',   10,11, 8,9)
469
1045
                ])
470
1046
 
 
1047
    def test_grouped_opcodes(self):
 
1048
        def chk_ops(a, b, expected_codes, n=3):
 
1049
            s = self._PatienceSequenceMatcher(None, a, b)
 
1050
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
 
1051
 
 
1052
        chk_ops('', '', [])
 
1053
        chk_ops([], [], [])
 
1054
        chk_ops('abc', '', [[('delete', 0,3, 0,0)]])
 
1055
        chk_ops('', 'abc', [[('insert', 0,0, 0,3)]])
 
1056
        chk_ops('abcd', 'abcd', [])
 
1057
        chk_ops('abcd', 'abce', [[('equal',   0,3, 0,3),
 
1058
                                  ('replace', 3,4, 3,4)
 
1059
                                 ]])
 
1060
        chk_ops('eabc', 'abce', [[('delete', 0,1, 0,0),
 
1061
                                 ('equal',  1,4, 0,3),
 
1062
                                 ('insert', 4,4, 3,4)
 
1063
                                ]])
 
1064
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
1065
                [[('equal',  3,6, 3,6),
 
1066
                  ('insert', 6,6, 6,11),
 
1067
                  ('equal',  6,9, 11,14)
 
1068
                  ]])
 
1069
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
1070
                [[('equal',  2,6, 2,6),
 
1071
                  ('insert', 6,6, 6,11),
 
1072
                  ('equal',  6,10, 11,15)
 
1073
                  ]], 4)
 
1074
        chk_ops('Xabcdef', 'abcdef',
 
1075
                [[('delete', 0,1, 0,0),
 
1076
                  ('equal',  1,4, 0,3)
 
1077
                  ]])
 
1078
        chk_ops('abcdef', 'abcdefX',
 
1079
                [[('equal',  3,6, 3,6),
 
1080
                  ('insert', 6,6, 6,7)
 
1081
                  ]])
 
1082
 
 
1083
 
471
1084
    def test_multiple_ranges(self):
472
1085
        # There was an earlier bug where we used a bad set of ranges,
473
1086
        # this triggers that specific bug, to make sure it doesn't regress
474
 
        def chk_blocks(a, b, expected_blocks):
475
 
            # difflib always adds a signature of the total
476
 
            # length, with no matching entries at the end
477
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
478
 
            blocks = s.get_matching_blocks()
479
 
            x = blocks.pop()
480
 
            self.assertEquals(x, (len(a), len(b), 0))
481
 
            self.assertEquals(expected_blocks, blocks)
482
 
 
483
 
        chk_blocks('abcdefghijklmnop'
484
 
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
485
 
                 , [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
486
 
 
487
 
        chk_blocks('ABCd efghIjk  L'
488
 
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
489
 
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
 
1087
        self.assertDiffBlocks('abcdefghijklmnop',
 
1088
                              'abcXghiYZQRSTUVWXYZijklmnop',
 
1089
                              [(0, 0, 3), (6, 4, 3), (9, 20, 7)])
 
1090
 
 
1091
        self.assertDiffBlocks('ABCd efghIjk  L',
 
1092
                              'AxyzBCn mo pqrstuvwI1 2  L',
 
1093
                              [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
490
1094
 
491
1095
        # These are rot13 code snippets.
492
 
        chk_blocks('''\
 
1096
        self.assertDiffBlocks('''\
493
1097
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
494
1098
    """
495
1099
    gnxrf_netf = ['svyr*']
496
1100
    gnxrf_bcgvbaf = ['ab-erphefr']
497
 
  
 
1101
 
498
1102
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
499
1103
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
500
1104
        vs vf_dhvrg():
508
1112
'''.splitlines(True), '''\
509
1113
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
510
1114
 
511
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
 
1115
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
512
1116
    nqq gurz.
513
1117
    """
514
1118
    gnxrf_netf = ['svyr*']
541
1145
                 'how are you today?\n']
542
1146
        txt_b = ['hello there\n',
543
1147
                 'how are you today?\n']
544
 
        unified_diff = bzrlib.patiencediff.unified_diff
545
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
546
 
        self.assertEquals([ '---  \n',
547
 
                           '+++  \n',
 
1148
        unified_diff = patiencediff.unified_diff
 
1149
        psm = self._PatienceSequenceMatcher
 
1150
        self.assertEquals(['--- \n',
 
1151
                           '+++ \n',
548
1152
                           '@@ -1,3 +1,2 @@\n',
549
1153
                           ' hello there\n',
550
1154
                           '-world\n',
555
1159
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
556
1160
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
557
1161
        # This is the result with LongestCommonSubstring matching
558
 
        self.assertEquals(['---  \n',
559
 
                           '+++  \n',
 
1162
        self.assertEquals(['--- \n',
 
1163
                           '+++ \n',
560
1164
                           '@@ -1,6 +1,11 @@\n',
561
1165
                           ' a\n',
562
1166
                           ' b\n',
571
1175
                           ' f\n']
572
1176
                          , list(unified_diff(txt_a, txt_b)))
573
1177
        # And the patience diff
574
 
        self.assertEquals(['---  \n',
575
 
                           '+++  \n',
 
1178
        self.assertEquals(['--- \n',
 
1179
                           '+++ \n',
576
1180
                           '@@ -4,6 +4,11 @@\n',
577
1181
                           ' d\n',
578
1182
                           ' e\n',
589
1193
                          , list(unified_diff(txt_a, txt_b,
590
1194
                                 sequencematcher=psm)))
591
1195
 
592
 
 
593
 
class TestPatienceDiffLibFiles(TestCaseInTempDir):
 
1196
    def test_patience_unified_diff_with_dates(self):
 
1197
        txt_a = ['hello there\n',
 
1198
                 'world\n',
 
1199
                 'how are you today?\n']
 
1200
        txt_b = ['hello there\n',
 
1201
                 'how are you today?\n']
 
1202
        unified_diff = patiencediff.unified_diff
 
1203
        psm = self._PatienceSequenceMatcher
 
1204
        self.assertEquals(['--- a\t2008-08-08\n',
 
1205
                           '+++ b\t2008-09-09\n',
 
1206
                           '@@ -1,3 +1,2 @@\n',
 
1207
                           ' hello there\n',
 
1208
                           '-world\n',
 
1209
                           ' how are you today?\n'
 
1210
                          ]
 
1211
                          , list(unified_diff(txt_a, txt_b,
 
1212
                                 fromfile='a', tofile='b',
 
1213
                                 fromfiledate='2008-08-08',
 
1214
                                 tofiledate='2008-09-09',
 
1215
                                 sequencematcher=psm)))
 
1216
 
 
1217
 
 
1218
class TestPatienceDiffLib_c(TestPatienceDiffLib):
 
1219
 
 
1220
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1221
 
 
1222
    def setUp(self):
 
1223
        super(TestPatienceDiffLib_c, self).setUp()
 
1224
        from bzrlib import _patiencediff_c
 
1225
        self._unique_lcs = _patiencediff_c.unique_lcs_c
 
1226
        self._recurse_matches = _patiencediff_c.recurse_matches_c
 
1227
        self._PatienceSequenceMatcher = \
 
1228
            _patiencediff_c.PatienceSequenceMatcher_c
 
1229
 
 
1230
    def test_unhashable(self):
 
1231
        """We should get a proper exception here."""
 
1232
        # We need to be able to hash items in the sequence, lists are
 
1233
        # unhashable, and thus cannot be diffed
 
1234
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1235
                                         None, [[]], [])
 
1236
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1237
                                         None, ['valid', []], [])
 
1238
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1239
                                         None, ['valid'], [[]])
 
1240
        e = self.assertRaises(TypeError, self._PatienceSequenceMatcher,
 
1241
                                         None, ['valid'], ['valid', []])
 
1242
 
 
1243
 
 
1244
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1245
 
 
1246
    def setUp(self):
 
1247
        super(TestPatienceDiffLibFiles, self).setUp()
 
1248
        self._PatienceSequenceMatcher = \
 
1249
            _patiencediff_py.PatienceSequenceMatcher_py
594
1250
 
595
1251
    def test_patience_unified_diff_files(self):
596
1252
        txt_a = ['hello there\n',
598
1254
                 'how are you today?\n']
599
1255
        txt_b = ['hello there\n',
600
1256
                 'how are you today?\n']
601
 
        open('a1', 'wb').writelines(txt_a)
602
 
        open('b1', 'wb').writelines(txt_b)
 
1257
        with open('a1', 'wb') as f: f.writelines(txt_a)
 
1258
        with open('b1', 'wb') as f: f.writelines(txt_b)
603
1259
 
604
 
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
605
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
606
 
        self.assertEquals(['--- a1 \n',
607
 
                           '+++ b1 \n',
 
1260
        unified_diff_files = patiencediff.unified_diff_files
 
1261
        psm = self._PatienceSequenceMatcher
 
1262
        self.assertEquals(['--- a1\n',
 
1263
                           '+++ b1\n',
608
1264
                           '@@ -1,3 +1,2 @@\n',
609
1265
                           ' hello there\n',
610
1266
                           '-world\n',
615
1271
 
616
1272
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
617
1273
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
618
 
        open('a2', 'wb').writelines(txt_a)
619
 
        open('b2', 'wb').writelines(txt_b)
 
1274
        with open('a2', 'wb') as f: f.writelines(txt_a)
 
1275
        with open('b2', 'wb') as f: f.writelines(txt_b)
620
1276
 
621
1277
        # This is the result with LongestCommonSubstring matching
622
 
        self.assertEquals(['--- a2 \n',
623
 
                           '+++ b2 \n',
 
1278
        self.assertEquals(['--- a2\n',
 
1279
                           '+++ b2\n',
624
1280
                           '@@ -1,6 +1,11 @@\n',
625
1281
                           ' a\n',
626
1282
                           ' b\n',
636
1292
                          , list(unified_diff_files('a2', 'b2')))
637
1293
 
638
1294
        # And the patience diff
639
 
        self.assertEquals(['--- a2 \n',
640
 
                           '+++ b2 \n',
 
1295
        self.assertEquals(['--- a2\n',
 
1296
                           '+++ b2\n',
641
1297
                           '@@ -4,6 +4,11 @@\n',
642
1298
                           ' d\n',
643
1299
                           ' e\n',
653
1309
                          ]
654
1310
                          , list(unified_diff_files('a2', 'b2',
655
1311
                                 sequencematcher=psm)))
 
1312
 
 
1313
 
 
1314
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
 
1315
 
 
1316
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1317
 
 
1318
    def setUp(self):
 
1319
        super(TestPatienceDiffLibFiles_c, self).setUp()
 
1320
        from bzrlib import _patiencediff_c
 
1321
        self._PatienceSequenceMatcher = \
 
1322
            _patiencediff_c.PatienceSequenceMatcher_c
 
1323
 
 
1324
 
 
1325
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1326
 
 
1327
    def test_PatienceSequenceMatcher(self):
 
1328
        if features.compiled_patiencediff_feature.available():
 
1329
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
 
1330
            self.assertIs(PatienceSequenceMatcher_c,
 
1331
                          patiencediff.PatienceSequenceMatcher)
 
1332
        else:
 
1333
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
 
1334
            self.assertIs(PatienceSequenceMatcher_py,
 
1335
                          patiencediff.PatienceSequenceMatcher)
 
1336
 
 
1337
    def test_unique_lcs(self):
 
1338
        if features.compiled_patiencediff_feature.available():
 
1339
            from bzrlib._patiencediff_c import unique_lcs_c
 
1340
            self.assertIs(unique_lcs_c,
 
1341
                          patiencediff.unique_lcs)
 
1342
        else:
 
1343
            from bzrlib._patiencediff_py import unique_lcs_py
 
1344
            self.assertIs(unique_lcs_py,
 
1345
                          patiencediff.unique_lcs)
 
1346
 
 
1347
    def test_recurse_matches(self):
 
1348
        if features.compiled_patiencediff_feature.available():
 
1349
            from bzrlib._patiencediff_c import recurse_matches_c
 
1350
            self.assertIs(recurse_matches_c,
 
1351
                          patiencediff.recurse_matches)
 
1352
        else:
 
1353
            from bzrlib._patiencediff_py import recurse_matches_py
 
1354
            self.assertIs(recurse_matches_py,
 
1355
                          patiencediff.recurse_matches)
 
1356
 
 
1357
 
 
1358
class TestDiffFromTool(tests.TestCaseWithTransport):
 
1359
 
 
1360
    def test_from_string(self):
 
1361
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
 
1362
        self.addCleanup(diff_obj.finish)
 
1363
        self.assertEqual(['diff', '@old_path', '@new_path'],
 
1364
            diff_obj.command_template)
 
1365
 
 
1366
    def test_from_string_u5(self):
 
1367
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
 
1368
                                                 None, None, None)
 
1369
        self.addCleanup(diff_obj.finish)
 
1370
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
 
1371
                         diff_obj.command_template)
 
1372
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
 
1373
                         diff_obj._get_command('old-path', 'new-path'))
 
1374
 
 
1375
    def test_from_string_path_with_backslashes(self):
 
1376
        self.requireFeature(features.backslashdir_feature)
 
1377
        tool = 'C:\\Tools\\Diff.exe'
 
1378
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
 
1379
        self.addCleanup(diff_obj.finish)
 
1380
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
 
1381
                         diff_obj.command_template)
 
1382
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
 
1383
                         diff_obj._get_command('old-path', 'new-path'))
 
1384
 
 
1385
    def test_execute(self):
 
1386
        output = StringIO()
 
1387
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1388
                                      'print "@old_path @new_path"'],
 
1389
                                     None, None, output)
 
1390
        self.addCleanup(diff_obj.finish)
 
1391
        diff_obj._execute('old', 'new')
 
1392
        self.assertEqual(output.getvalue().rstrip(), 'old new')
 
1393
 
 
1394
    def test_excute_missing(self):
 
1395
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1396
                                     None, None, None)
 
1397
        self.addCleanup(diff_obj.finish)
 
1398
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
 
1399
                              'old', 'new')
 
1400
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
 
1401
                         ' on this machine', str(e))
 
1402
 
 
1403
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
 
1404
        self.requireFeature(features.AttribFeature)
 
1405
        output = StringIO()
 
1406
        tree = self.make_branch_and_tree('tree')
 
1407
        self.build_tree_contents([('tree/file', 'content')])
 
1408
        tree.add('file', 'file-id')
 
1409
        tree.commit('old tree')
 
1410
        tree.lock_read()
 
1411
        self.addCleanup(tree.unlock)
 
1412
        basis_tree = tree.basis_tree()
 
1413
        basis_tree.lock_read()
 
1414
        self.addCleanup(basis_tree.unlock)
 
1415
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1416
                                      'print "@old_path @new_path"'],
 
1417
                                     basis_tree, tree, output)
 
1418
        diff_obj._prepare_files('file-id', 'file', 'file')
 
1419
        # The old content should be readonly
 
1420
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
 
1421
                                    r'R.*old\\file$')
 
1422
        # The new content should use the tree object, not a 'new' file anymore
 
1423
        self.assertEndsWith(tree.basedir, 'work/tree')
 
1424
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
 
1425
 
 
1426
    def assertReadableByAttrib(self, cwd, relpath, regex):
 
1427
        proc = subprocess.Popen(['attrib', relpath],
 
1428
                                stdout=subprocess.PIPE,
 
1429
                                cwd=cwd)
 
1430
        (result, err) = proc.communicate()
 
1431
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
 
1432
 
 
1433
    def test_prepare_files(self):
 
1434
        output = StringIO()
 
1435
        tree = self.make_branch_and_tree('tree')
 
1436
        self.build_tree_contents([('tree/oldname', 'oldcontent')])
 
1437
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
 
1438
        tree.add('oldname', 'file-id')
 
1439
        tree.add('oldname2', 'file2-id')
 
1440
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
 
1441
        tree.commit('old tree', timestamp=315532800)
 
1442
        tree.rename_one('oldname', 'newname')
 
1443
        tree.rename_one('oldname2', 'newname2')
 
1444
        self.build_tree_contents([('tree/newname', 'newcontent')])
 
1445
        self.build_tree_contents([('tree/newname2', 'newcontent2')])
 
1446
        old_tree = tree.basis_tree()
 
1447
        old_tree.lock_read()
 
1448
        self.addCleanup(old_tree.unlock)
 
1449
        tree.lock_read()
 
1450
        self.addCleanup(tree.unlock)
 
1451
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1452
                                      'print "@old_path @new_path"'],
 
1453
                                     old_tree, tree, output)
 
1454
        self.addCleanup(diff_obj.finish)
 
1455
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
 
1456
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
 
1457
                                                     'newname')
 
1458
        self.assertContainsRe(old_path, 'old/oldname$')
 
1459
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
 
1460
        self.assertContainsRe(new_path, 'tree/newname$')
 
1461
        self.assertFileEqual('oldcontent', old_path)
 
1462
        self.assertFileEqual('newcontent', new_path)
 
1463
        if osutils.host_os_dereferences_symlinks():
 
1464
            self.assertTrue(os.path.samefile('tree/newname', new_path))
 
1465
        # make sure we can create files with the same parent directories
 
1466
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
 
1467
 
 
1468
 
 
1469
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
 
1470
 
 
1471
    def test_encodable_filename(self):
 
1472
        # Just checks file path for external diff tool.
 
1473
        # We cannot change CPython's internal encoding used by os.exec*.
 
1474
        import sys
 
1475
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1476
                                    None, None, None)
 
1477
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1478
            encoding = scenario['encoding']
 
1479
            dirname  = scenario['info']['directory']
 
1480
            filename = scenario['info']['filename']
 
1481
 
 
1482
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1483
            relpath = dirname + u'/' + filename
 
1484
            fullpath = diffobj._safe_filename('safe', relpath)
 
1485
            self.assertEqual(
 
1486
                    fullpath,
 
1487
                    fullpath.encode(encoding).decode(encoding)
 
1488
                    )
 
1489
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1490
 
 
1491
    def test_unencodable_filename(self):
 
1492
        import sys
 
1493
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1494
                                    None, None, None)
 
1495
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1496
            encoding = scenario['encoding']
 
1497
            dirname  = scenario['info']['directory']
 
1498
            filename = scenario['info']['filename']
 
1499
 
 
1500
            if encoding == 'iso-8859-1':
 
1501
                encoding = 'iso-8859-2'
 
1502
            else:
 
1503
                encoding = 'iso-8859-1'
 
1504
 
 
1505
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1506
            relpath = dirname + u'/' + filename
 
1507
            fullpath = diffobj._safe_filename('safe', relpath)
 
1508
            self.assertEqual(
 
1509
                    fullpath,
 
1510
                    fullpath.encode(encoding).decode(encoding)
 
1511
                    )
 
1512
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1513
 
 
1514
 
 
1515
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
 
1516
 
 
1517
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
 
1518
        """Call get_trees_and_branches_to_diff_locked."""
 
1519
        return diff.get_trees_and_branches_to_diff_locked(
 
1520
            path_list, revision_specs, old_url, new_url, self.addCleanup)
 
1521
 
 
1522
    def test_basic(self):
 
1523
        tree = self.make_branch_and_tree('tree')
 
1524
        (old_tree, new_tree,
 
1525
         old_branch, new_branch,
 
1526
         specific_files, extra_trees) = self.call_gtabtd(
 
1527
             ['tree'], None, None, None)
 
1528
 
 
1529
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1530
        self.assertEqual(_mod_revision.NULL_REVISION,
 
1531
                         old_tree.get_revision_id())
 
1532
        self.assertEqual(tree.basedir, new_tree.basedir)
 
1533
        self.assertEqual(tree.branch.base, old_branch.base)
 
1534
        self.assertEqual(tree.branch.base, new_branch.base)
 
1535
        self.assertIs(None, specific_files)
 
1536
        self.assertIs(None, extra_trees)
 
1537
 
 
1538
    def test_with_rev_specs(self):
 
1539
        tree = self.make_branch_and_tree('tree')
 
1540
        self.build_tree_contents([('tree/file', 'oldcontent')])
 
1541
        tree.add('file', 'file-id')
 
1542
        tree.commit('old tree', timestamp=0, rev_id="old-id")
 
1543
        self.build_tree_contents([('tree/file', 'newcontent')])
 
1544
        tree.commit('new tree', timestamp=0, rev_id="new-id")
 
1545
 
 
1546
        revisions = [revisionspec.RevisionSpec.from_string('1'),
 
1547
                     revisionspec.RevisionSpec.from_string('2')]
 
1548
        (old_tree, new_tree,
 
1549
         old_branch, new_branch,
 
1550
         specific_files, extra_trees) = self.call_gtabtd(
 
1551
            ['tree'], revisions, None, None)
 
1552
 
 
1553
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1554
        self.assertEqual("old-id", old_tree.get_revision_id())
 
1555
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
 
1556
        self.assertEqual("new-id", new_tree.get_revision_id())
 
1557
        self.assertEqual(tree.branch.base, old_branch.base)
 
1558
        self.assertEqual(tree.branch.base, new_branch.base)
 
1559
        self.assertIs(None, specific_files)
 
1560
        self.assertEqual(tree.basedir, extra_trees[0].basedir)