← 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: Jelmer Vernooij
  • Date: 2010-04-30 11:03:59 UTC
  • mto: This revision was merged to the branch mainline in revision 5197.
  • Revision ID: jelmer@samba.org-20100430110359-ow3e3grh7sxy93pa
Remove more unused imports.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
 
18
import os.path
18
19
from cStringIO import StringIO
 
20
import errno
19
21
import subprocess
20
22
import sys
21
 
import tempfile
 
23
from tempfile import TemporaryFile
22
24
 
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,
 
25
from bzrlib import tests
 
26
from bzrlib.diff import (
 
27
    DiffFromTool,
 
28
    DiffPath,
 
29
    DiffSymlink,
 
30
    DiffTree,
 
31
    DiffText,
 
32
    external_diff,
 
33
    internal_diff,
 
34
    show_diff_trees,
 
35
    get_trees_and_branches_to_diff,
34
36
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import features
37
 
from bzrlib.tests.blackbox.test_diff import subst_dates
38
 
 
39
 
 
40
 
class _AttribFeature(tests.Feature):
 
37
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
 
38
import bzrlib.osutils as osutils
 
39
import bzrlib.revision as _mod_revision
 
40
import bzrlib.transform as transform
 
41
import bzrlib.patiencediff
 
42
import bzrlib._patiencediff_py
 
43
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
44
                          TestCaseInTempDir, TestSkipped)
 
45
from bzrlib.revisiontree import RevisionTree
 
46
from bzrlib.revisionspec import RevisionSpec
 
47
 
 
48
from bzrlib.tests.test_win32utils import BackslashDirSeparatorFeature
 
49
 
 
50
 
 
51
class _AttribFeature(Feature):
41
52
 
42
53
    def _probe(self):
43
54
        if (sys.platform not in ('cygwin', 'win32')):
60
71
 
61
72
def udiff_lines(old, new, allow_binary=False):
62
73
    output = StringIO()
63
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
74
    internal_diff('old', old, 'new', new, output, allow_binary)
64
75
    output.seek(0, 0)
65
76
    return output.readlines()
66
77
 
70
81
        # StringIO has no fileno, so it tests a different codepath
71
82
        output = StringIO()
72
83
    else:
73
 
        output = tempfile.TemporaryFile()
 
84
        output = TemporaryFile()
74
85
    try:
75
 
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
76
 
    except errors.NoDiff:
77
 
        raise tests.TestSkipped('external "diff" not present to test')
 
86
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
87
    except NoDiff:
 
88
        raise TestSkipped('external "diff" not present to test')
78
89
    output.seek(0, 0)
79
90
    lines = output.readlines()
80
91
    output.close()
81
92
    return lines
82
93
 
83
94
 
84
 
class TestDiff(tests.TestCase):
 
95
class TestDiff(TestCase):
85
96
 
86
97
    def test_add_nl(self):
87
98
        """diff generates a valid diff for patches that add a newline"""
123
134
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
124
135
 
125
136
    def test_binary_lines(self):
126
 
        empty = []
127
 
        uni_lines = [1023 * 'a' + '\x00']
128
 
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
129
 
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
130
 
        udiff_lines(uni_lines , empty, allow_binary=True)
131
 
        udiff_lines(empty, uni_lines, allow_binary=True)
 
137
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
138
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
139
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
140
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
132
141
 
133
142
    def test_external_diff(self):
134
143
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
144
153
        self.check_patch(lines)
145
154
 
146
155
    def test_external_diff_binary_lang_c(self):
 
156
        old_env = {}
147
157
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
148
 
            self.overrideEnv(lang, 'C')
149
 
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
150
 
        # Older versions of diffutils say "Binary files", newer
151
 
        # versions just say "Files".
152
 
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
153
 
        self.assertEquals(lines[1:], ['\n'])
 
158
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
159
        try:
 
160
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
161
            # Older versions of diffutils say "Binary files", newer
 
162
            # versions just say "Files".
 
163
            self.assertContainsRe(lines[0],
 
164
                                  '(Binary f|F)iles old and new differ\n')
 
165
            self.assertEquals(lines[1:], ['\n'])
 
166
        finally:
 
167
            for lang, old_val in old_env.iteritems():
 
168
                osutils.set_or_unset_env(lang, old_val)
154
169
 
155
170
    def test_no_external_diff(self):
156
171
        """Check that NoDiff is raised when diff is not available"""
157
 
        # Make sure no 'diff' command is available
158
 
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
159
 
        self.overrideEnv('PATH', '')
160
 
        self.assertRaises(errors.NoDiff, diff.external_diff,
161
 
                          'old', ['boo\n'], 'new', ['goo\n'],
162
 
                          StringIO(), diff_opts=['-u'])
 
172
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
173
        orig_path = os.environ['PATH']
 
174
        try:
 
175
            os.environ['PATH'] = ''
 
176
            self.assertRaises(NoDiff, external_diff,
 
177
                              'old', ['boo\n'], 'new', ['goo\n'],
 
178
                              StringIO(), diff_opts=['-u'])
 
179
        finally:
 
180
            os.environ['PATH'] = orig_path
163
181
 
164
182
    def test_internal_diff_default(self):
165
183
        # Default internal diff encoding is utf8
166
184
        output = StringIO()
167
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
168
 
                           u'new_\xe5', ['new_text\n'], output)
 
185
        internal_diff(u'old_\xb5', ['old_text\n'],
 
186
                    u'new_\xe5', ['new_text\n'], output)
169
187
        lines = output.getvalue().splitlines(True)
170
188
        self.check_patch(lines)
171
189
        self.assertEquals(['--- old_\xc2\xb5\n',
179
197
 
180
198
    def test_internal_diff_utf8(self):
181
199
        output = StringIO()
182
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
183
 
                           u'new_\xe5', ['new_text\n'], output,
184
 
                           path_encoding='utf8')
 
200
        internal_diff(u'old_\xb5', ['old_text\n'],
 
201
                    u'new_\xe5', ['new_text\n'], output,
 
202
                    path_encoding='utf8')
185
203
        lines = output.getvalue().splitlines(True)
186
204
        self.check_patch(lines)
187
205
        self.assertEquals(['--- old_\xc2\xb5\n',
195
213
 
196
214
    def test_internal_diff_iso_8859_1(self):
197
215
        output = StringIO()
198
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
199
 
                           u'new_\xe5', ['new_text\n'], output,
200
 
                           path_encoding='iso-8859-1')
 
216
        internal_diff(u'old_\xb5', ['old_text\n'],
 
217
                    u'new_\xe5', ['new_text\n'], output,
 
218
                    path_encoding='iso-8859-1')
201
219
        lines = output.getvalue().splitlines(True)
202
220
        self.check_patch(lines)
203
221
        self.assertEquals(['--- old_\xb5\n',
211
229
 
212
230
    def test_internal_diff_no_content(self):
213
231
        output = StringIO()
214
 
        diff.internal_diff(u'old', [], u'new', [], output)
 
232
        internal_diff(u'old', [], u'new', [], output)
215
233
        self.assertEqual('', output.getvalue())
216
234
 
217
235
    def test_internal_diff_no_changes(self):
218
236
        output = StringIO()
219
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
220
 
                           u'new', ['text\n', 'contents\n'],
221
 
                           output)
 
237
        internal_diff(u'old', ['text\n', 'contents\n'],
 
238
                      u'new', ['text\n', 'contents\n'],
 
239
                      output)
222
240
        self.assertEqual('', output.getvalue())
223
241
 
224
242
    def test_internal_diff_returns_bytes(self):
225
243
        import StringIO
226
244
        output = StringIO.StringIO()
227
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
228
 
                            u'new_\xe5', ['new_text\n'], output)
229
 
        self.assertIsInstance(output.getvalue(), str,
 
245
        internal_diff(u'old_\xb5', ['old_text\n'],
 
246
                    u'new_\xe5', ['new_text\n'], output)
 
247
        self.failUnless(isinstance(output.getvalue(), str),
230
248
            'internal_diff should return bytestrings')
231
249
 
232
250
 
233
 
class TestDiffFiles(tests.TestCaseInTempDir):
 
251
class TestDiffFiles(TestCaseInTempDir):
234
252
 
235
253
    def test_external_diff_binary(self):
236
254
        """The output when using external diff should use diff's i18n error"""
249
267
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
250
268
 
251
269
 
252
 
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
253
 
    output = StringIO()
254
 
    if working_tree is not None:
255
 
        extra_trees = (working_tree,)
256
 
    else:
257
 
        extra_trees = ()
258
 
    diff.show_diff_trees(tree1, tree2, output,
259
 
        specific_files=specific_files,
260
 
        extra_trees=extra_trees, old_label='old/',
261
 
        new_label='new/')
262
 
    return output.getvalue()
263
 
 
264
 
 
265
 
class TestDiffDates(tests.TestCaseWithTransport):
 
270
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
271
    """Has a helper for running show_diff_trees"""
 
272
 
 
273
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
274
        output = StringIO()
 
275
        if working_tree is not None:
 
276
            extra_trees = (working_tree,)
 
277
        else:
 
278
            extra_trees = ()
 
279
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
280
                        extra_trees=extra_trees, old_label='old/',
 
281
                        new_label='new/')
 
282
        return output.getvalue()
 
283
 
 
284
 
 
285
class TestDiffDates(TestShowDiffTreesHelper):
266
286
 
267
287
    def setUp(self):
268
288
        super(TestDiffDates, self).setUp()
303
323
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
304
324
 
305
325
    def test_diff_rev_tree_working_tree(self):
306
 
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
 
326
        output = self.get_diff(self.wt.basis_tree(), self.wt)
307
327
        # note that the date for old/file1 is from rev 2 rather than from
308
328
        # the basis revision (rev 4)
309
329
        self.assertEqualDiff(output, '''\
319
339
    def test_diff_rev_tree_rev_tree(self):
320
340
        tree1 = self.b.repository.revision_tree('rev-2')
321
341
        tree2 = self.b.repository.revision_tree('rev-3')
322
 
        output = get_diff_as_string(tree1, tree2)
 
342
        output = self.get_diff(tree1, tree2)
323
343
        self.assertEqualDiff(output, '''\
324
344
=== modified file 'file2'
325
345
--- old/file2\t2006-04-01 00:00:00 +0000
333
353
    def test_diff_add_files(self):
334
354
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
335
355
        tree2 = self.b.repository.revision_tree('rev-1')
336
 
        output = get_diff_as_string(tree1, tree2)
 
356
        output = self.get_diff(tree1, tree2)
337
357
        # the files have the epoch time stamp for the tree in which
338
358
        # they don't exist.
339
359
        self.assertEqualDiff(output, '''\
354
374
    def test_diff_remove_files(self):
355
375
        tree1 = self.b.repository.revision_tree('rev-3')
356
376
        tree2 = self.b.repository.revision_tree('rev-4')
357
 
        output = get_diff_as_string(tree1, tree2)
 
377
        output = self.get_diff(tree1, tree2)
358
378
        # the file has the epoch time stamp for the tree in which
359
379
        # it doesn't exist.
360
380
        self.assertEqualDiff(output, '''\
371
391
        self.wt.rename_one('file1', 'file1b')
372
392
        old_tree = self.b.repository.revision_tree('rev-1')
373
393
        new_tree = self.b.repository.revision_tree('rev-4')
374
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
 
394
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
375
395
                            working_tree=self.wt)
376
396
        self.assertContainsRe(out, 'file1\t')
377
397
 
383
403
        self.wt.rename_one('file1', 'dir1/file1')
384
404
        old_tree = self.b.repository.revision_tree('rev-1')
385
405
        new_tree = self.b.repository.revision_tree('rev-4')
386
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
 
406
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
387
407
                            working_tree=self.wt)
388
408
        self.assertContainsRe(out, 'file1\t')
389
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
 
409
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
390
410
                            working_tree=self.wt)
391
411
        self.assertNotContainsRe(out, 'file1\t')
392
412
 
393
413
 
394
 
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
414
 
 
415
class TestShowDiffTrees(TestShowDiffTreesHelper):
395
416
    """Direct tests for show_diff_trees"""
396
417
 
397
418
    def test_modified_file(self):
402
423
        tree.commit('one', rev_id='rev-1')
403
424
 
404
425
        self.build_tree_contents([('tree/file', 'new contents\n')])
405
 
        d = get_diff_as_string(tree.basis_tree(), tree)
406
 
        self.assertContainsRe(d, "=== modified file 'file'\n")
407
 
        self.assertContainsRe(d, '--- old/file\t')
408
 
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
409
 
        self.assertContainsRe(d, '-contents\n'
410
 
                                 '\\+new contents\n')
 
426
        diff = self.get_diff(tree.basis_tree(), tree)
 
427
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
428
        self.assertContainsRe(diff, '--- old/file\t')
 
429
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
430
        self.assertContainsRe(diff, '-contents\n'
 
431
                                    '\\+new contents\n')
411
432
 
412
433
    def test_modified_file_in_renamed_dir(self):
413
434
        """Test when a file is modified in a renamed directory."""
419
440
 
420
441
        tree.rename_one('dir', 'other')
421
442
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
422
 
        d = get_diff_as_string(tree.basis_tree(), tree)
423
 
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
424
 
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
443
        diff = self.get_diff(tree.basis_tree(), tree)
 
444
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
445
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
425
446
        # XXX: This is technically incorrect, because it used to be at another
426
447
        # location. What to do?
427
 
        self.assertContainsRe(d, '--- old/dir/file\t')
428
 
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
429
 
        self.assertContainsRe(d, '-contents\n'
430
 
                                 '\\+new contents\n')
 
448
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
449
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
450
        self.assertContainsRe(diff, '-contents\n'
 
451
                                    '\\+new contents\n')
431
452
 
432
453
    def test_renamed_directory(self):
433
454
        """Test when only a directory is only renamed."""
438
459
        tree.commit('one', rev_id='rev-1')
439
460
 
440
461
        tree.rename_one('dir', 'newdir')
441
 
        d = get_diff_as_string(tree.basis_tree(), tree)
 
462
        diff = self.get_diff(tree.basis_tree(), tree)
442
463
        # Renaming a directory should be a single "you renamed this dir" even
443
464
        # when there are files inside.
444
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
465
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
445
466
 
446
467
    def test_renamed_file(self):
447
468
        """Test when a file is only renamed."""
451
472
        tree.commit('one', rev_id='rev-1')
452
473
 
453
474
        tree.rename_one('file', 'newname')
454
 
        d = get_diff_as_string(tree.basis_tree(), tree)
455
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
475
        diff = self.get_diff(tree.basis_tree(), tree)
 
476
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
456
477
        # We shouldn't have a --- or +++ line, because there is no content
457
478
        # change
458
 
        self.assertNotContainsRe(d, '---')
 
479
        self.assertNotContainsRe(diff, '---')
459
480
 
460
481
    def test_renamed_and_modified_file(self):
461
482
        """Test when a file is only renamed."""
466
487
 
467
488
        tree.rename_one('file', 'newname')
468
489
        self.build_tree_contents([('tree/newname', 'new contents\n')])
469
 
        d = get_diff_as_string(tree.basis_tree(), tree)
470
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
471
 
        self.assertContainsRe(d, '--- old/file\t')
472
 
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
473
 
        self.assertContainsRe(d, '-contents\n'
474
 
                                 '\\+new contents\n')
 
490
        diff = self.get_diff(tree.basis_tree(), tree)
 
491
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
492
        self.assertContainsRe(diff, '--- old/file\t')
 
493
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
494
        self.assertContainsRe(diff, '-contents\n'
 
495
                                    '\\+new contents\n')
475
496
 
476
497
 
477
498
    def test_internal_diff_exec_property(self):
496
517
        tree.rename_one('c', 'new-c')
497
518
        tree.rename_one('d', 'new-d')
498
519
 
499
 
        d = get_diff_as_string(tree.basis_tree(), tree)
500
 
 
501
 
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
502
 
                                  ".*\+x to -x.*\)")
503
 
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
504
 
                                  ".*-x to \+x.*\)")
505
 
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
506
 
                                  ".*\+x to -x.*\)")
507
 
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
508
 
                                  ".*-x to \+x.*\)")
509
 
        self.assertNotContainsRe(d, r"file 'e'")
510
 
        self.assertNotContainsRe(d, r"file 'f'")
 
520
        diff = self.get_diff(tree.basis_tree(), tree)
 
521
 
 
522
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
 
523
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
 
524
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
 
525
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
 
526
        self.assertNotContainsRe(diff, r"file 'e'")
 
527
        self.assertNotContainsRe(diff, r"file 'f'")
 
528
 
511
529
 
512
530
    def test_binary_unicode_filenames(self):
513
531
        """Test that contents of files are *not* encoded in UTF-8 when there
528
546
        tree.add([alpha], ['file-id'])
529
547
        tree.add([omega], ['file-id-2'])
530
548
        diff_content = StringIO()
531
 
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
532
 
        d = diff_content.getvalue()
533
 
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
534
 
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
535
 
                              % (alpha_utf8, alpha_utf8))
536
 
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
537
 
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
538
 
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
 
549
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
550
        diff = diff_content.getvalue()
 
551
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
552
        self.assertContainsRe(
 
553
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
554
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
555
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
556
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
539
557
 
540
558
    def test_unicode_filename(self):
541
559
        """Test when the filename are unicode."""
560
578
        tree.add(['add_'+alpha], ['file-id'])
561
579
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
562
580
 
563
 
        d = get_diff_as_string(tree.basis_tree(), tree)
564
 
        self.assertContainsRe(d,
 
581
        diff = self.get_diff(tree.basis_tree(), tree)
 
582
        self.assertContainsRe(diff,
565
583
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
566
 
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
567
 
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
568
 
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
569
 
 
570
 
    def test_unicode_filename_path_encoding(self):
571
 
        """Test for bug #382699: unicode filenames on Windows should be shown
572
 
        in user encoding.
573
 
        """
574
 
        self.requireFeature(tests.UnicodeFilenameFeature)
575
 
        # The word 'test' in Russian
576
 
        _russian_test = u'\u0422\u0435\u0441\u0442'
577
 
        directory = _russian_test + u'/'
578
 
        test_txt = _russian_test + u'.txt'
579
 
        u1234 = u'\u1234.txt'
580
 
 
581
 
        tree = self.make_branch_and_tree('.')
582
 
        self.build_tree_contents([
583
 
            (test_txt, 'foo\n'),
584
 
            (u1234, 'foo\n'),
585
 
            (directory, None),
586
 
            ])
587
 
        tree.add([test_txt, u1234, directory])
588
 
 
589
 
        sio = StringIO()
590
 
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
591
 
            path_encoding='cp1251')
592
 
 
593
 
        output = subst_dates(sio.getvalue())
594
 
        shouldbe = ('''\
595
 
=== added directory '%(directory)s'
596
 
=== added file '%(test_txt)s'
597
 
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
598
 
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
599
 
@@ -0,0 +1,1 @@
600
 
+foo
601
 
 
602
 
=== added file '?.txt'
603
 
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
604
 
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
605
 
@@ -0,0 +1,1 @@
606
 
+foo
607
 
 
608
 
''' % {'directory': _russian_test.encode('cp1251'),
609
 
       'test_txt': test_txt.encode('cp1251'),
610
 
      })
611
 
        self.assertEqualDiff(output, shouldbe)
612
 
 
613
 
 
614
 
class DiffWasIs(diff.DiffPath):
 
584
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
585
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
586
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
587
 
 
588
 
 
589
class DiffWasIs(DiffPath):
615
590
 
616
591
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
617
592
        self.to_file.write('was: ')
621
596
        pass
622
597
 
623
598
 
624
 
class TestDiffTree(tests.TestCaseWithTransport):
 
599
class TestDiffTree(TestCaseWithTransport):
625
600
 
626
601
    def setUp(self):
627
 
        super(TestDiffTree, self).setUp()
 
602
        TestCaseWithTransport.setUp(self)
628
603
        self.old_tree = self.make_branch_and_tree('old-tree')
629
604
        self.old_tree.lock_write()
630
605
        self.addCleanup(self.old_tree.unlock)
631
606
        self.new_tree = self.make_branch_and_tree('new-tree')
632
607
        self.new_tree.lock_write()
633
608
        self.addCleanup(self.new_tree.unlock)
634
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
609
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
635
610
 
636
611
    def test_diff_text(self):
637
612
        self.build_tree_contents([('old-tree/olddir/',),
642
617
                                  ('new-tree/newdir/newfile', 'new\n')])
643
618
        self.new_tree.add('newdir')
644
619
        self.new_tree.add('newdir/newfile', 'file-id')
645
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
620
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
646
621
        differ.diff_text('file-id', None, 'old label', 'new label')
647
622
        self.assertEqual(
648
623
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
677
652
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
678
653
 
679
654
    def test_diff_symlink(self):
680
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
655
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
681
656
        differ.diff_symlink('old target', None)
682
657
        self.assertEqual("=== target was 'old target'\n",
683
658
                         differ.to_file.getvalue())
684
659
 
685
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
660
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
686
661
        differ.diff_symlink(None, 'new target')
687
662
        self.assertEqual("=== target is 'new target'\n",
688
663
                         differ.to_file.getvalue())
689
664
 
690
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
665
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
691
666
        differ.diff_symlink('old target', 'new target')
692
667
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
693
668
                         differ.to_file.getvalue())
743
718
 
744
719
    def test_register_diff(self):
745
720
        self.create_old_new()
746
 
        old_diff_factories = diff.DiffTree.diff_factories
747
 
        diff.DiffTree.diff_factories=old_diff_factories[:]
748
 
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
721
        old_diff_factories = DiffTree.diff_factories
 
722
        DiffTree.diff_factories=old_diff_factories[:]
 
723
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
749
724
        try:
750
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
725
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
751
726
        finally:
752
 
            diff.DiffTree.diff_factories = old_diff_factories
 
727
            DiffTree.diff_factories = old_diff_factories
753
728
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
754
729
        self.assertNotContainsRe(
755
730
            differ.to_file.getvalue(),
760
735
 
761
736
    def test_extra_factories(self):
762
737
        self.create_old_new()
763
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
764
 
                               extra_factories=[DiffWasIs.from_diff_tree])
 
738
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
739
                            extra_factories=[DiffWasIs.from_diff_tree])
765
740
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
766
741
        self.assertNotContainsRe(
767
742
            differ.to_file.getvalue(),
780
755
            '.*a-file(.|\n)*b-file')
781
756
 
782
757
 
783
 
class TestPatienceDiffLib(tests.TestCase):
 
758
class TestPatienceDiffLib(TestCase):
784
759
 
785
760
    def setUp(self):
786
761
        super(TestPatienceDiffLib, self).setUp()
787
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
788
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
762
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
763
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
789
764
        self._PatienceSequenceMatcher = \
790
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
765
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
791
766
 
792
767
    def test_diff_unicode_string(self):
793
768
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
1100
1075
                 'how are you today?\n']
1101
1076
        txt_b = ['hello there\n',
1102
1077
                 'how are you today?\n']
1103
 
        unified_diff = patiencediff.unified_diff
 
1078
        unified_diff = bzrlib.patiencediff.unified_diff
1104
1079
        psm = self._PatienceSequenceMatcher
1105
1080
        self.assertEquals(['--- \n',
1106
1081
                           '+++ \n',
1154
1129
                 'how are you today?\n']
1155
1130
        txt_b = ['hello there\n',
1156
1131
                 'how are you today?\n']
1157
 
        unified_diff = patiencediff.unified_diff
 
1132
        unified_diff = bzrlib.patiencediff.unified_diff
1158
1133
        psm = self._PatienceSequenceMatcher
1159
1134
        self.assertEquals(['--- a\t2008-08-08\n',
1160
1135
                           '+++ b\t2008-09-09\n',
1176
1151
 
1177
1152
    def setUp(self):
1178
1153
        super(TestPatienceDiffLib_c, self).setUp()
1179
 
        from bzrlib import _patiencediff_c
1180
 
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1181
 
        self._recurse_matches = _patiencediff_c.recurse_matches_c
 
1154
        import bzrlib._patiencediff_c
 
1155
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1156
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
1182
1157
        self._PatienceSequenceMatcher = \
1183
 
            _patiencediff_c.PatienceSequenceMatcher_c
 
1158
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1184
1159
 
1185
1160
    def test_unhashable(self):
1186
1161
        """We should get a proper exception here."""
1196
1171
                                         None, ['valid'], ['valid', []])
1197
1172
 
1198
1173
 
1199
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1174
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1200
1175
 
1201
1176
    def setUp(self):
1202
1177
        super(TestPatienceDiffLibFiles, self).setUp()
1203
1178
        self._PatienceSequenceMatcher = \
1204
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
1179
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1205
1180
 
1206
1181
    def test_patience_unified_diff_files(self):
1207
1182
        txt_a = ['hello there\n',
1212
1187
        open('a1', 'wb').writelines(txt_a)
1213
1188
        open('b1', 'wb').writelines(txt_b)
1214
1189
 
1215
 
        unified_diff_files = patiencediff.unified_diff_files
 
1190
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1216
1191
        psm = self._PatienceSequenceMatcher
1217
1192
        self.assertEquals(['--- a1\n',
1218
1193
                           '+++ b1\n',
1272
1247
 
1273
1248
    def setUp(self):
1274
1249
        super(TestPatienceDiffLibFiles_c, self).setUp()
1275
 
        from bzrlib import _patiencediff_c
 
1250
        import bzrlib._patiencediff_c
1276
1251
        self._PatienceSequenceMatcher = \
1277
 
            _patiencediff_c.PatienceSequenceMatcher_c
1278
 
 
1279
 
 
1280
 
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1252
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1253
 
 
1254
 
 
1255
class TestUsingCompiledIfAvailable(TestCase):
1281
1256
 
1282
1257
    def test_PatienceSequenceMatcher(self):
1283
1258
        if compiled_patiencediff_feature.available():
1284
1259
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1285
1260
            self.assertIs(PatienceSequenceMatcher_c,
1286
 
                          patiencediff.PatienceSequenceMatcher)
 
1261
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1287
1262
        else:
1288
1263
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1289
1264
            self.assertIs(PatienceSequenceMatcher_py,
1290
 
                          patiencediff.PatienceSequenceMatcher)
 
1265
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1291
1266
 
1292
1267
    def test_unique_lcs(self):
1293
1268
        if compiled_patiencediff_feature.available():
1294
1269
            from bzrlib._patiencediff_c import unique_lcs_c
1295
1270
            self.assertIs(unique_lcs_c,
1296
 
                          patiencediff.unique_lcs)
 
1271
                          bzrlib.patiencediff.unique_lcs)
1297
1272
        else:
1298
1273
            from bzrlib._patiencediff_py import unique_lcs_py
1299
1274
            self.assertIs(unique_lcs_py,
1300
 
                          patiencediff.unique_lcs)
 
1275
                          bzrlib.patiencediff.unique_lcs)
1301
1276
 
1302
1277
    def test_recurse_matches(self):
1303
1278
        if compiled_patiencediff_feature.available():
1304
1279
            from bzrlib._patiencediff_c import recurse_matches_c
1305
1280
            self.assertIs(recurse_matches_c,
1306
 
                          patiencediff.recurse_matches)
 
1281
                          bzrlib.patiencediff.recurse_matches)
1307
1282
        else:
1308
1283
            from bzrlib._patiencediff_py import recurse_matches_py
1309
1284
            self.assertIs(recurse_matches_py,
1310
 
                          patiencediff.recurse_matches)
1311
 
 
1312
 
 
1313
 
class TestDiffFromTool(tests.TestCaseWithTransport):
 
1285
                          bzrlib.patiencediff.recurse_matches)
 
1286
 
 
1287
 
 
1288
class TestDiffFromTool(TestCaseWithTransport):
1314
1289
 
1315
1290
    def test_from_string(self):
1316
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
 
1291
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
1317
1292
        self.addCleanup(diff_obj.finish)
1318
1293
        self.assertEqual(['diff', '@old_path', '@new_path'],
1319
1294
            diff_obj.command_template)
1320
1295
 
1321
1296
    def test_from_string_u5(self):
1322
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1323
 
                                                 None, None, None)
 
1297
        diff_obj = DiffFromTool.from_string('diff "-u 5"', None, None, None)
1324
1298
        self.addCleanup(diff_obj.finish)
1325
1299
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1326
1300
                         diff_obj.command_template)
1327
1301
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1328
1302
                         diff_obj._get_command('old-path', 'new-path'))
1329
 
 
 
1303
        
1330
1304
    def test_from_string_path_with_backslashes(self):
1331
 
        self.requireFeature(features.backslashdir_feature)
 
1305
        self.requireFeature(BackslashDirSeparatorFeature)
1332
1306
        tool = 'C:\\Tools\\Diff.exe'
1333
 
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
 
1307
        diff_obj = DiffFromTool.from_string(tool, None, None, None)
1334
1308
        self.addCleanup(diff_obj.finish)
1335
1309
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1336
1310
                         diff_obj.command_template)
1339
1313
 
1340
1314
    def test_execute(self):
1341
1315
        output = StringIO()
1342
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1343
 
                                      'print "@old_path @new_path"'],
1344
 
                                     None, None, output)
 
1316
        diff_obj = DiffFromTool(['python', '-c',
 
1317
                                 'print "@old_path @new_path"'],
 
1318
                                None, None, output)
1345
1319
        self.addCleanup(diff_obj.finish)
1346
1320
        diff_obj._execute('old', 'new')
1347
1321
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1348
1322
 
1349
1323
    def test_excute_missing(self):
1350
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1351
 
                                     None, None, None)
 
1324
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1325
                                None, None, None)
1352
1326
        self.addCleanup(diff_obj.finish)
1353
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1354
 
                              'old', 'new')
 
1327
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
 
1328
                              'new')
1355
1329
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1356
1330
                         ' on this machine', str(e))
1357
1331
 
1367
1341
        basis_tree = tree.basis_tree()
1368
1342
        basis_tree.lock_read()
1369
1343
        self.addCleanup(basis_tree.unlock)
1370
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1371
 
                                      'print "@old_path @new_path"'],
1372
 
                                     basis_tree, tree, output)
 
1344
        diff_obj = DiffFromTool(['python', '-c',
 
1345
                                 'print "@old_path @new_path"'],
 
1346
                                basis_tree, tree, output)
1373
1347
        diff_obj._prepare_files('file-id', 'file', 'file')
1374
1348
        # The old content should be readonly
1375
1349
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1392
1366
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1393
1367
        tree.add('oldname', 'file-id')
1394
1368
        tree.add('oldname2', 'file2-id')
1395
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1396
 
        tree.commit('old tree', timestamp=315532800)
 
1369
        tree.commit('old tree', timestamp=0)
1397
1370
        tree.rename_one('oldname', 'newname')
1398
1371
        tree.rename_one('oldname2', 'newname2')
1399
1372
        self.build_tree_contents([('tree/newname', 'newcontent')])
1403
1376
        self.addCleanup(old_tree.unlock)
1404
1377
        tree.lock_read()
1405
1378
        self.addCleanup(tree.unlock)
1406
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1407
 
                                      'print "@old_path @new_path"'],
1408
 
                                     old_tree, tree, output)
 
1379
        diff_obj = DiffFromTool(['python', '-c',
 
1380
                                 'print "@old_path @new_path"'],
 
1381
                                old_tree, tree, output)
1409
1382
        self.addCleanup(diff_obj.finish)
1410
1383
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1411
1384
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1412
1385
                                                     'newname')
1413
1386
        self.assertContainsRe(old_path, 'old/oldname$')
1414
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
 
1387
        self.assertEqual(0, os.stat(old_path).st_mtime)
1415
1388
        self.assertContainsRe(new_path, 'tree/newname$')
1416
1389
        self.assertFileEqual('oldcontent', old_path)
1417
1390
        self.assertFileEqual('newcontent', new_path)
1421
1394
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1422
1395
 
1423
1396
 
1424
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1425
 
 
1426
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1427
 
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
1428
 
        TestGetTreesAndBranchesToDiff.
1429
 
        """
1430
 
        return diff.get_trees_and_branches_to_diff_locked(
1431
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
 
1397
class TestGetTreesAndBranchesToDiff(TestCaseWithTransport):
1432
1398
 
1433
1399
    def test_basic(self):
1434
1400
        tree = self.make_branch_and_tree('tree')
1435
1401
        (old_tree, new_tree,
1436
1402
         old_branch, new_branch,
1437
 
         specific_files, extra_trees) = self.call_gtabtd(
1438
 
             ['tree'], None, None, None)
 
1403
         specific_files, extra_trees) = \
 
1404
            get_trees_and_branches_to_diff(['tree'], None, None, None)
1439
1405
 
1440
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1441
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1442
 
                         old_tree.get_revision_id())
 
1406
        self.assertIsInstance(old_tree, RevisionTree)
 
1407
        #print dir (old_tree)
 
1408
        self.assertEqual(_mod_revision.NULL_REVISION, old_tree.get_revision_id())
1443
1409
        self.assertEqual(tree.basedir, new_tree.basedir)
1444
1410
        self.assertEqual(tree.branch.base, old_branch.base)
1445
1411
        self.assertEqual(tree.branch.base, new_branch.base)
1454
1420
        self.build_tree_contents([('tree/file', 'newcontent')])
1455
1421
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1456
1422
 
1457
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1458
 
                     revisionspec.RevisionSpec.from_string('2')]
 
1423
        revisions = [RevisionSpec.from_string('1'),
 
1424
                     RevisionSpec.from_string('2')]
1459
1425
        (old_tree, new_tree,
1460
1426
         old_branch, new_branch,
1461
 
         specific_files, extra_trees) = self.call_gtabtd(
1462
 
            ['tree'], revisions, None, None)
 
1427
         specific_files, extra_trees) = \
 
1428
            get_trees_and_branches_to_diff(['tree'], revisions, None, None)
1463
1429
 
1464
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1430
        self.assertIsInstance(old_tree, RevisionTree)
1465
1431
        self.assertEqual("old-id", old_tree.get_revision_id())
1466
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
 
1432
        self.assertIsInstance(new_tree, RevisionTree)
1467
1433
        self.assertEqual("new-id", new_tree.get_revision_id())
1468
1434
        self.assertEqual(tree.branch.base, old_branch.base)
1469
1435
        self.assertEqual(tree.branch.base, new_branch.base)
1470
1436
        self.assertIs(None, specific_files)
1471
1437
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
1472
 
 
1473
 
 
1474
 
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
1475
 
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
1476
 
    deprecated get_trees_and_branches_to_diff function.
1477
 
    """
1478
 
 
1479
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1480
 
        return self.applyDeprecated(
1481
 
            deprecated_in((2, 2, 0)), diff.get_trees_and_branches_to_diff,
1482
 
            path_list, revision_specs, old_url, new_url)