← 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: Launchpad Translations on behalf of bzr-core
  • Date: 2012-11-25 04:30:35 UTC
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: launchpad_translations_on_behalf_of_bzr-core-20121125043035-9abma98g1j6p5uox
Launchpad automatic translations update.

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
 
 
198
 
class TestDiffFiles(TestCaseInTempDir):
 
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):
199
279
 
200
280
    def test_external_diff_binary(self):
201
281
        """The output when using external diff should use diff's i18n error"""
203
283
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
204
284
 
205
285
        cmd = ['diff', '-u', '--binary', 'old', 'new']
206
 
        open('old', 'wb').write('\x00foobar\n')
207
 
        open('new', 'wb').write('foo\x00bar\n')
 
286
        with open('old', 'wb') as f: f.write('\x00foobar\n')
 
287
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
208
288
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
209
289
                                     stdin=subprocess.PIPE)
210
290
        out, err = pipe.communicate()
214
294
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
215
295
 
216
296
 
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):
 
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):
233
311
 
234
312
    def setUp(self):
235
313
        super(TestDiffDates, self).setUp()
270
348
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
271
349
 
272
350
    def test_diff_rev_tree_working_tree(self):
273
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
351
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
274
352
        # note that the date for old/file1 is from rev 2 rather than from
275
353
        # the basis revision (rev 4)
276
354
        self.assertEqualDiff(output, '''\
286
364
    def test_diff_rev_tree_rev_tree(self):
287
365
        tree1 = self.b.repository.revision_tree('rev-2')
288
366
        tree2 = self.b.repository.revision_tree('rev-3')
289
 
        output = self.get_diff(tree1, tree2)
 
367
        output = get_diff_as_string(tree1, tree2)
290
368
        self.assertEqualDiff(output, '''\
291
369
=== modified file 'file2'
292
370
--- old/file2\t2006-04-01 00:00:00 +0000
296
374
+file2 contents at rev 3
297
375
 
298
376
''')
299
 
        
 
377
 
300
378
    def test_diff_add_files(self):
301
 
        tree1 = self.b.repository.revision_tree(None)
 
379
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
302
380
        tree2 = self.b.repository.revision_tree('rev-1')
303
 
        output = self.get_diff(tree1, tree2)
 
381
        output = get_diff_as_string(tree1, tree2)
304
382
        # the files have the epoch time stamp for the tree in which
305
383
        # they don't exist.
306
384
        self.assertEqualDiff(output, '''\
321
399
    def test_diff_remove_files(self):
322
400
        tree1 = self.b.repository.revision_tree('rev-3')
323
401
        tree2 = self.b.repository.revision_tree('rev-4')
324
 
        output = self.get_diff(tree1, tree2)
 
402
        output = get_diff_as_string(tree1, tree2)
325
403
        # the file has the epoch time stamp for the tree in which
326
404
        # it doesn't exist.
327
405
        self.assertEqualDiff(output, '''\
338
416
        self.wt.rename_one('file1', 'file1b')
339
417
        old_tree = self.b.repository.revision_tree('rev-1')
340
418
        new_tree = self.b.repository.revision_tree('rev-4')
341
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
 
419
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
342
420
                            working_tree=self.wt)
343
421
        self.assertContainsRe(out, 'file1\t')
344
422
 
350
428
        self.wt.rename_one('file1', 'dir1/file1')
351
429
        old_tree = self.b.repository.revision_tree('rev-1')
352
430
        new_tree = self.b.repository.revision_tree('rev-4')
353
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
 
431
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
354
432
                            working_tree=self.wt)
355
433
        self.assertContainsRe(out, 'file1\t')
356
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
 
434
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
357
435
                            working_tree=self.wt)
358
436
        self.assertNotContainsRe(out, 'file1\t')
359
437
 
360
438
 
361
 
 
362
 
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
439
class TestShowDiffTrees(tests.TestCaseWithTransport):
363
440
    """Direct tests for show_diff_trees"""
364
441
 
365
442
    def test_modified_file(self):
370
447
        tree.commit('one', rev_id='rev-1')
371
448
 
372
449
        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')
 
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')
379
456
 
380
457
    def test_modified_file_in_renamed_dir(self):
381
458
        """Test when a file is modified in a renamed directory."""
387
464
 
388
465
        tree.rename_one('dir', 'other')
389
466
        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")
 
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")
393
470
        # XXX: This is technically incorrect, because it used to be at another
394
471
        # 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')
 
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')
399
476
 
400
477
    def test_renamed_directory(self):
401
478
        """Test when only a directory is only renamed."""
406
483
        tree.commit('one', rev_id='rev-1')
407
484
 
408
485
        tree.rename_one('dir', 'newdir')
409
 
        diff = self.get_diff(tree.basis_tree(), tree)
 
486
        d = get_diff_as_string(tree.basis_tree(), tree)
410
487
        # Renaming a directory should be a single "you renamed this dir" even
411
488
        # when there are files inside.
412
 
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
 
489
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
413
490
 
414
491
    def test_renamed_file(self):
415
492
        """Test when a file is only renamed."""
419
496
        tree.commit('one', rev_id='rev-1')
420
497
 
421
498
        tree.rename_one('file', 'newname')
422
 
        diff = self.get_diff(tree.basis_tree(), tree)
423
 
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
499
        d = get_diff_as_string(tree.basis_tree(), tree)
 
500
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
424
501
        # We shouldn't have a --- or +++ line, because there is no content
425
502
        # change
426
 
        self.assertNotContainsRe(diff, '---')
 
503
        self.assertNotContainsRe(d, '---')
427
504
 
428
505
    def test_renamed_and_modified_file(self):
429
506
        """Test when a file is only renamed."""
434
511
 
435
512
        tree.rename_one('file', 'newname')
436
513
        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):
 
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))
446
843
 
447
844
    def test_unique_lcs(self):
448
 
        unique_lcs = bzrlib.patiencediff.unique_lcs
 
845
        unique_lcs = self._unique_lcs
449
846
        self.assertEquals(unique_lcs('', ''), [])
 
847
        self.assertEquals(unique_lcs('', 'a'), [])
 
848
        self.assertEquals(unique_lcs('a', ''), [])
450
849
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
451
850
        self.assertEquals(unique_lcs('a', 'b'), [])
452
851
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
453
852
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
454
853
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
455
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
 
854
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
456
855
                                                         (3,3), (4,4)])
457
856
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
458
857
 
459
858
    def test_recurse_matches(self):
460
859
        def test_one(a, b, matches):
461
860
            test_matches = []
462
 
            bzrlib.patiencediff.recurse_matches(a, b, 0, 0, len(a), len(b),
463
 
                test_matches, 10)
 
861
            self._recurse_matches(
 
862
                a, b, 0, 0, len(a), len(b), test_matches, 10)
464
863
            self.assertEquals(test_matches, matches)
465
864
 
466
865
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
467
866
                 [(0, 0), (2, 2), (4, 4)])
468
867
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
469
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)])
470
874
 
471
 
        # recurse_matches doesn't match non-unique 
 
875
        # recurse_matches doesn't match non-unique
472
876
        # lines surrounded by bogus text.
473
877
        # The update has been done in patiencediff.SequenceMatcher instead
474
878
 
478
882
        # This is what it currently gives:
479
883
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
480
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
 
481
899
    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
900
        # 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 
 
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
501
913
        # a copied block stays attached to the previous section,
502
914
        # not the later one.
503
915
        # difflib would tend to grab the trailing longest match
504
916
        # which would make the diff not look right
505
 
        chk_blocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
506
 
                   [(0, 0, 6), (6, 11, 10)])
 
917
        self.assertDiffBlocks('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
918
                              [(0, 0, 6), (6, 11, 10)])
507
919
 
508
920
        # make sure it supports passing in lists
509
 
        chk_blocks(
 
921
        self.assertDiffBlocks(
510
922
                   ['hello there\n',
511
923
                    'world\n',
512
924
                    'how are you today?\n'],
516
928
 
517
929
        # non unique lines surrounded by non-matching lines
518
930
        # won't be found
519
 
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
931
        self.assertDiffBlocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
520
932
 
521
933
        # But they only need to be locally unique
522
 
        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)])
523
935
 
524
936
        # non unique blocks won't be matched
525
 
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
937
        self.assertDiffBlocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
526
938
 
527
939
        # but locally unique ones will
528
 
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
940
        self.assertDiffBlocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
529
941
                                              (5,4,1), (7,5,2), (10,8,1)])
530
942
 
531
 
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
532
 
        chk_blocks('abbabbbb', 'cabbabbc', [])
533
 
        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)])
534
970
 
535
971
    def test_opcodes(self):
536
972
        def chk_ops(a, b, expected_codes):
537
 
            s = bzrlib.patiencediff.PatienceSequenceMatcher(None, a, b)
 
973
            s = self._PatienceSequenceMatcher(None, a, b)
538
974
            self.assertEquals(expected_codes, s.get_opcodes())
539
975
 
540
976
        chk_ops('', '', [])
541
977
        chk_ops([], [], [])
 
978
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
 
979
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
542
980
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
543
981
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
544
982
                                 ('replace', 3,4, 3,4)
577
1015
                 ('delete', 1,2, 1,1),
578
1016
                 ('equal',  2,3, 1,2),
579
1017
                ])
580
 
        chk_ops('aBccDe', 'abccde', 
 
1018
        chk_ops('aBccDe', 'abccde',
581
1019
                [('equal',   0,1, 0,1),
582
1020
                 ('replace', 1,5, 1,5),
583
1021
                 ('equal',   5,6, 5,6),
584
1022
                ])
585
 
        chk_ops('aBcDec', 'abcdec', 
 
1023
        chk_ops('aBcDec', 'abcdec',
586
1024
                [('equal',   0,1, 0,1),
587
1025
                 ('replace', 1,2, 1,2),
588
1026
                 ('equal',   2,3, 2,3),
589
1027
                 ('replace', 3,4, 3,4),
590
1028
                 ('equal',   4,6, 4,6),
591
1029
                ])
592
 
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
 
1030
        chk_ops('aBcdEcdFg', 'abcdecdfg',
593
1031
                [('equal',   0,1, 0,1),
594
1032
                 ('replace', 1,8, 1,8),
595
1033
                 ('equal',   8,9, 8,9)
596
1034
                ])
597
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
 
1035
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
598
1036
                [('equal',   0,1, 0,1),
599
1037
                 ('replace', 1,2, 1,2),
600
1038
                 ('equal',   2,4, 2,4),
606
1044
                 ('equal',   10,11, 8,9)
607
1045
                ])
608
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
 
609
1084
    def test_multiple_ranges(self):
610
1085
        # There was an earlier bug where we used a bad set of ranges,
611
1086
        # 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)])
 
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)])
628
1094
 
629
1095
        # These are rot13 code snippets.
630
 
        chk_blocks('''\
 
1096
        self.assertDiffBlocks('''\
631
1097
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
632
1098
    """
633
1099
    gnxrf_netf = ['svyr*']
634
1100
    gnxrf_bcgvbaf = ['ab-erphefr']
635
 
  
 
1101
 
636
1102
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
637
1103
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
638
1104
        vs vf_dhvrg():
646
1112
'''.splitlines(True), '''\
647
1113
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
648
1114
 
649
 
    --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
650
1116
    nqq gurz.
651
1117
    """
652
1118
    gnxrf_netf = ['svyr*']
679
1145
                 'how are you today?\n']
680
1146
        txt_b = ['hello there\n',
681
1147
                 'how are you today?\n']
682
 
        unified_diff = bzrlib.patiencediff.unified_diff
683
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
684
 
        self.assertEquals([ '---  \n',
685
 
                           '+++  \n',
 
1148
        unified_diff = patiencediff.unified_diff
 
1149
        psm = self._PatienceSequenceMatcher
 
1150
        self.assertEquals(['--- \n',
 
1151
                           '+++ \n',
686
1152
                           '@@ -1,3 +1,2 @@\n',
687
1153
                           ' hello there\n',
688
1154
                           '-world\n',
693
1159
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
694
1160
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
695
1161
        # This is the result with LongestCommonSubstring matching
696
 
        self.assertEquals(['---  \n',
697
 
                           '+++  \n',
 
1162
        self.assertEquals(['--- \n',
 
1163
                           '+++ \n',
698
1164
                           '@@ -1,6 +1,11 @@\n',
699
1165
                           ' a\n',
700
1166
                           ' b\n',
709
1175
                           ' f\n']
710
1176
                          , list(unified_diff(txt_a, txt_b)))
711
1177
        # And the patience diff
712
 
        self.assertEquals(['---  \n',
713
 
                           '+++  \n',
 
1178
        self.assertEquals(['--- \n',
 
1179
                           '+++ \n',
714
1180
                           '@@ -4,6 +4,11 @@\n',
715
1181
                           ' d\n',
716
1182
                           ' e\n',
727
1193
                          , list(unified_diff(txt_a, txt_b,
728
1194
                                 sequencematcher=psm)))
729
1195
 
730
 
 
731
 
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
732
1250
 
733
1251
    def test_patience_unified_diff_files(self):
734
1252
        txt_a = ['hello there\n',
736
1254
                 'how are you today?\n']
737
1255
        txt_b = ['hello there\n',
738
1256
                 'how are you today?\n']
739
 
        open('a1', 'wb').writelines(txt_a)
740
 
        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)
741
1259
 
742
 
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
743
 
        psm = bzrlib.patiencediff.PatienceSequenceMatcher
744
 
        self.assertEquals(['--- a1 \n',
745
 
                           '+++ b1 \n',
 
1260
        unified_diff_files = patiencediff.unified_diff_files
 
1261
        psm = self._PatienceSequenceMatcher
 
1262
        self.assertEquals(['--- a1\n',
 
1263
                           '+++ b1\n',
746
1264
                           '@@ -1,3 +1,2 @@\n',
747
1265
                           ' hello there\n',
748
1266
                           '-world\n',
753
1271
 
754
1272
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
755
1273
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
756
 
        open('a2', 'wb').writelines(txt_a)
757
 
        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)
758
1276
 
759
1277
        # This is the result with LongestCommonSubstring matching
760
 
        self.assertEquals(['--- a2 \n',
761
 
                           '+++ b2 \n',
 
1278
        self.assertEquals(['--- a2\n',
 
1279
                           '+++ b2\n',
762
1280
                           '@@ -1,6 +1,11 @@\n',
763
1281
                           ' a\n',
764
1282
                           ' b\n',
774
1292
                          , list(unified_diff_files('a2', 'b2')))
775
1293
 
776
1294
        # And the patience diff
777
 
        self.assertEquals(['--- a2 \n',
778
 
                           '+++ b2 \n',
 
1295
        self.assertEquals(['--- a2\n',
 
1296
                           '+++ b2\n',
779
1297
                           '@@ -4,6 +4,11 @@\n',
780
1298
                           ' d\n',
781
1299
                           ' e\n',
791
1309
                          ]
792
1310
                          , list(unified_diff_files('a2', 'b2',
793
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)