← 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: Canonical.com Patch Queue Manager
  • Date: 2010-02-11 04:02:41 UTC
  • mfrom: (5017.2.2 tariff)
  • Revision ID: pqm@pqm.ubuntu.com-20100211040241-w6n021dz0uus341n
(mbp) add import-tariff tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
22
 
 
23
 
from bzrlib import (
24
 
    diff,
25
 
    errors,
26
 
    osutils,
27
 
    patiencediff,
28
 
    _patiencediff_py,
29
 
    revision as _mod_revision,
30
 
    revisionspec,
31
 
    revisiontree,
32
 
    tests,
33
 
    transform,
34
 
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import features, EncodingAdapter
37
 
from bzrlib.tests.blackbox.test_diff import subst_dates
38
 
from bzrlib.tests import (
39
 
    features,
40
 
    )
 
23
from tempfile import TemporaryFile
 
24
 
 
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,
 
36
    )
 
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
 
 
49
class _AttribFeature(Feature):
 
50
 
 
51
    def _probe(self):
 
52
        if (sys.platform not in ('cygwin', 'win32')):
 
53
            return False
 
54
        try:
 
55
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
 
56
        except OSError, e:
 
57
            return False
 
58
        return (0 == proc.wait())
 
59
 
 
60
    def feature_name(self):
 
61
        return 'attrib Windows command-line tool'
 
62
 
 
63
AttribFeature = _AttribFeature()
 
64
 
 
65
 
 
66
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
 
67
                                    'bzrlib._patiencediff_c')
41
68
 
42
69
 
43
70
def udiff_lines(old, new, allow_binary=False):
44
71
    output = StringIO()
45
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
72
    internal_diff('old', old, 'new', new, output, allow_binary)
46
73
    output.seek(0, 0)
47
74
    return output.readlines()
48
75
 
52
79
        # StringIO has no fileno, so it tests a different codepath
53
80
        output = StringIO()
54
81
    else:
55
 
        output = tempfile.TemporaryFile()
 
82
        output = TemporaryFile()
56
83
    try:
57
 
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
58
 
    except errors.NoDiff:
59
 
        raise tests.TestSkipped('external "diff" not present to test')
 
84
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
85
    except NoDiff:
 
86
        raise TestSkipped('external "diff" not present to test')
60
87
    output.seek(0, 0)
61
88
    lines = output.readlines()
62
89
    output.close()
63
90
    return lines
64
91
 
65
92
 
66
 
class TestDiff(tests.TestCase):
 
93
class TestDiff(TestCase):
67
94
 
68
95
    def test_add_nl(self):
69
96
        """diff generates a valid diff for patches that add a newline"""
105
132
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
106
133
 
107
134
    def test_binary_lines(self):
108
 
        empty = []
109
 
        uni_lines = [1023 * 'a' + '\x00']
110
 
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
111
 
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
112
 
        udiff_lines(uni_lines , empty, allow_binary=True)
113
 
        udiff_lines(empty, uni_lines, allow_binary=True)
 
135
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
136
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
137
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
138
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
114
139
 
115
140
    def test_external_diff(self):
116
141
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
126
151
        self.check_patch(lines)
127
152
 
128
153
    def test_external_diff_binary_lang_c(self):
 
154
        old_env = {}
129
155
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
130
 
            self.overrideEnv(lang, 'C')
131
 
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
132
 
        # Older versions of diffutils say "Binary files", newer
133
 
        # versions just say "Files".
134
 
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
135
 
        self.assertEquals(lines[1:], ['\n'])
 
156
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
157
        try:
 
158
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
159
            # Older versions of diffutils say "Binary files", newer
 
160
            # versions just say "Files".
 
161
            self.assertContainsRe(lines[0],
 
162
                                  '(Binary f|F)iles old and new differ\n')
 
163
            self.assertEquals(lines[1:], ['\n'])
 
164
        finally:
 
165
            for lang, old_val in old_env.iteritems():
 
166
                osutils.set_or_unset_env(lang, old_val)
136
167
 
137
168
    def test_no_external_diff(self):
138
169
        """Check that NoDiff is raised when diff is not available"""
139
 
        # Make sure no 'diff' command is available
140
 
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
141
 
        self.overrideEnv('PATH', '')
142
 
        self.assertRaises(errors.NoDiff, diff.external_diff,
143
 
                          'old', ['boo\n'], 'new', ['goo\n'],
144
 
                          StringIO(), diff_opts=['-u'])
 
170
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
171
        orig_path = os.environ['PATH']
 
172
        try:
 
173
            os.environ['PATH'] = ''
 
174
            self.assertRaises(NoDiff, external_diff,
 
175
                              'old', ['boo\n'], 'new', ['goo\n'],
 
176
                              StringIO(), diff_opts=['-u'])
 
177
        finally:
 
178
            os.environ['PATH'] = orig_path
145
179
 
146
180
    def test_internal_diff_default(self):
147
181
        # Default internal diff encoding is utf8
148
182
        output = StringIO()
149
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
150
 
                           u'new_\xe5', ['new_text\n'], output)
 
183
        internal_diff(u'old_\xb5', ['old_text\n'],
 
184
                    u'new_\xe5', ['new_text\n'], output)
151
185
        lines = output.getvalue().splitlines(True)
152
186
        self.check_patch(lines)
153
187
        self.assertEquals(['--- old_\xc2\xb5\n',
161
195
 
162
196
    def test_internal_diff_utf8(self):
163
197
        output = StringIO()
164
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
165
 
                           u'new_\xe5', ['new_text\n'], output,
166
 
                           path_encoding='utf8')
 
198
        internal_diff(u'old_\xb5', ['old_text\n'],
 
199
                    u'new_\xe5', ['new_text\n'], output,
 
200
                    path_encoding='utf8')
167
201
        lines = output.getvalue().splitlines(True)
168
202
        self.check_patch(lines)
169
203
        self.assertEquals(['--- old_\xc2\xb5\n',
177
211
 
178
212
    def test_internal_diff_iso_8859_1(self):
179
213
        output = StringIO()
180
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
181
 
                           u'new_\xe5', ['new_text\n'], output,
182
 
                           path_encoding='iso-8859-1')
 
214
        internal_diff(u'old_\xb5', ['old_text\n'],
 
215
                    u'new_\xe5', ['new_text\n'], output,
 
216
                    path_encoding='iso-8859-1')
183
217
        lines = output.getvalue().splitlines(True)
184
218
        self.check_patch(lines)
185
219
        self.assertEquals(['--- old_\xb5\n',
193
227
 
194
228
    def test_internal_diff_no_content(self):
195
229
        output = StringIO()
196
 
        diff.internal_diff(u'old', [], u'new', [], output)
 
230
        internal_diff(u'old', [], u'new', [], output)
197
231
        self.assertEqual('', output.getvalue())
198
232
 
199
233
    def test_internal_diff_no_changes(self):
200
234
        output = StringIO()
201
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
202
 
                           u'new', ['text\n', 'contents\n'],
203
 
                           output)
 
235
        internal_diff(u'old', ['text\n', 'contents\n'],
 
236
                      u'new', ['text\n', 'contents\n'],
 
237
                      output)
204
238
        self.assertEqual('', output.getvalue())
205
239
 
206
240
    def test_internal_diff_returns_bytes(self):
207
241
        import StringIO
208
242
        output = StringIO.StringIO()
209
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
210
 
                            u'new_\xe5', ['new_text\n'], output)
211
 
        self.assertIsInstance(output.getvalue(), str,
 
243
        internal_diff(u'old_\xb5', ['old_text\n'],
 
244
                    u'new_\xe5', ['new_text\n'], output)
 
245
        self.failUnless(isinstance(output.getvalue(), str),
212
246
            'internal_diff should return bytestrings')
213
247
 
214
248
 
215
 
class TestDiffFiles(tests.TestCaseInTempDir):
 
249
class TestDiffFiles(TestCaseInTempDir):
216
250
 
217
251
    def test_external_diff_binary(self):
218
252
        """The output when using external diff should use diff's i18n error"""
231
265
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
232
266
 
233
267
 
234
 
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
235
 
    output = StringIO()
236
 
    if working_tree is not None:
237
 
        extra_trees = (working_tree,)
238
 
    else:
239
 
        extra_trees = ()
240
 
    diff.show_diff_trees(tree1, tree2, output,
241
 
        specific_files=specific_files,
242
 
        extra_trees=extra_trees, old_label='old/',
243
 
        new_label='new/')
244
 
    return output.getvalue()
245
 
 
246
 
 
247
 
class TestDiffDates(tests.TestCaseWithTransport):
 
268
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
269
    """Has a helper for running show_diff_trees"""
 
270
 
 
271
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
272
        output = StringIO()
 
273
        if working_tree is not None:
 
274
            extra_trees = (working_tree,)
 
275
        else:
 
276
            extra_trees = ()
 
277
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
278
                        extra_trees=extra_trees, old_label='old/',
 
279
                        new_label='new/')
 
280
        return output.getvalue()
 
281
 
 
282
 
 
283
class TestDiffDates(TestShowDiffTreesHelper):
248
284
 
249
285
    def setUp(self):
250
286
        super(TestDiffDates, self).setUp()
285
321
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
286
322
 
287
323
    def test_diff_rev_tree_working_tree(self):
288
 
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
 
324
        output = self.get_diff(self.wt.basis_tree(), self.wt)
289
325
        # note that the date for old/file1 is from rev 2 rather than from
290
326
        # the basis revision (rev 4)
291
327
        self.assertEqualDiff(output, '''\
301
337
    def test_diff_rev_tree_rev_tree(self):
302
338
        tree1 = self.b.repository.revision_tree('rev-2')
303
339
        tree2 = self.b.repository.revision_tree('rev-3')
304
 
        output = get_diff_as_string(tree1, tree2)
 
340
        output = self.get_diff(tree1, tree2)
305
341
        self.assertEqualDiff(output, '''\
306
342
=== modified file 'file2'
307
343
--- old/file2\t2006-04-01 00:00:00 +0000
315
351
    def test_diff_add_files(self):
316
352
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
317
353
        tree2 = self.b.repository.revision_tree('rev-1')
318
 
        output = get_diff_as_string(tree1, tree2)
 
354
        output = self.get_diff(tree1, tree2)
319
355
        # the files have the epoch time stamp for the tree in which
320
356
        # they don't exist.
321
357
        self.assertEqualDiff(output, '''\
336
372
    def test_diff_remove_files(self):
337
373
        tree1 = self.b.repository.revision_tree('rev-3')
338
374
        tree2 = self.b.repository.revision_tree('rev-4')
339
 
        output = get_diff_as_string(tree1, tree2)
 
375
        output = self.get_diff(tree1, tree2)
340
376
        # the file has the epoch time stamp for the tree in which
341
377
        # it doesn't exist.
342
378
        self.assertEqualDiff(output, '''\
353
389
        self.wt.rename_one('file1', 'file1b')
354
390
        old_tree = self.b.repository.revision_tree('rev-1')
355
391
        new_tree = self.b.repository.revision_tree('rev-4')
356
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
 
392
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
357
393
                            working_tree=self.wt)
358
394
        self.assertContainsRe(out, 'file1\t')
359
395
 
365
401
        self.wt.rename_one('file1', 'dir1/file1')
366
402
        old_tree = self.b.repository.revision_tree('rev-1')
367
403
        new_tree = self.b.repository.revision_tree('rev-4')
368
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
 
404
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
369
405
                            working_tree=self.wt)
370
406
        self.assertContainsRe(out, 'file1\t')
371
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
 
407
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
372
408
                            working_tree=self.wt)
373
409
        self.assertNotContainsRe(out, 'file1\t')
374
410
 
375
411
 
376
 
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
412
 
 
413
class TestShowDiffTrees(TestShowDiffTreesHelper):
377
414
    """Direct tests for show_diff_trees"""
378
415
 
379
416
    def test_modified_file(self):
384
421
        tree.commit('one', rev_id='rev-1')
385
422
 
386
423
        self.build_tree_contents([('tree/file', 'new contents\n')])
387
 
        d = get_diff_as_string(tree.basis_tree(), tree)
388
 
        self.assertContainsRe(d, "=== modified file 'file'\n")
389
 
        self.assertContainsRe(d, '--- old/file\t')
390
 
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
391
 
        self.assertContainsRe(d, '-contents\n'
392
 
                                 '\\+new contents\n')
 
424
        diff = self.get_diff(tree.basis_tree(), tree)
 
425
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
426
        self.assertContainsRe(diff, '--- old/file\t')
 
427
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
428
        self.assertContainsRe(diff, '-contents\n'
 
429
                                    '\\+new contents\n')
393
430
 
394
431
    def test_modified_file_in_renamed_dir(self):
395
432
        """Test when a file is modified in a renamed directory."""
401
438
 
402
439
        tree.rename_one('dir', 'other')
403
440
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
404
 
        d = get_diff_as_string(tree.basis_tree(), tree)
405
 
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
406
 
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
441
        diff = self.get_diff(tree.basis_tree(), tree)
 
442
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
443
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
407
444
        # XXX: This is technically incorrect, because it used to be at another
408
445
        # location. What to do?
409
 
        self.assertContainsRe(d, '--- old/dir/file\t')
410
 
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
411
 
        self.assertContainsRe(d, '-contents\n'
412
 
                                 '\\+new contents\n')
 
446
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
447
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
448
        self.assertContainsRe(diff, '-contents\n'
 
449
                                    '\\+new contents\n')
413
450
 
414
451
    def test_renamed_directory(self):
415
452
        """Test when only a directory is only renamed."""
420
457
        tree.commit('one', rev_id='rev-1')
421
458
 
422
459
        tree.rename_one('dir', 'newdir')
423
 
        d = get_diff_as_string(tree.basis_tree(), tree)
 
460
        diff = self.get_diff(tree.basis_tree(), tree)
424
461
        # Renaming a directory should be a single "you renamed this dir" even
425
462
        # when there are files inside.
426
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
463
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
427
464
 
428
465
    def test_renamed_file(self):
429
466
        """Test when a file is only renamed."""
433
470
        tree.commit('one', rev_id='rev-1')
434
471
 
435
472
        tree.rename_one('file', 'newname')
436
 
        d = get_diff_as_string(tree.basis_tree(), tree)
437
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
473
        diff = self.get_diff(tree.basis_tree(), tree)
 
474
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
438
475
        # We shouldn't have a --- or +++ line, because there is no content
439
476
        # change
440
 
        self.assertNotContainsRe(d, '---')
 
477
        self.assertNotContainsRe(diff, '---')
441
478
 
442
479
    def test_renamed_and_modified_file(self):
443
480
        """Test when a file is only renamed."""
448
485
 
449
486
        tree.rename_one('file', 'newname')
450
487
        self.build_tree_contents([('tree/newname', 'new contents\n')])
451
 
        d = get_diff_as_string(tree.basis_tree(), tree)
452
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
453
 
        self.assertContainsRe(d, '--- old/file\t')
454
 
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
455
 
        self.assertContainsRe(d, '-contents\n'
456
 
                                 '\\+new contents\n')
 
488
        diff = self.get_diff(tree.basis_tree(), tree)
 
489
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
490
        self.assertContainsRe(diff, '--- old/file\t')
 
491
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
492
        self.assertContainsRe(diff, '-contents\n'
 
493
                                    '\\+new contents\n')
457
494
 
458
495
 
459
496
    def test_internal_diff_exec_property(self):
478
515
        tree.rename_one('c', 'new-c')
479
516
        tree.rename_one('d', 'new-d')
480
517
 
481
 
        d = get_diff_as_string(tree.basis_tree(), tree)
482
 
 
483
 
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
484
 
                                  ".*\+x to -x.*\)")
485
 
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
486
 
                                  ".*-x to \+x.*\)")
487
 
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
488
 
                                  ".*\+x to -x.*\)")
489
 
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
490
 
                                  ".*-x to \+x.*\)")
491
 
        self.assertNotContainsRe(d, r"file 'e'")
492
 
        self.assertNotContainsRe(d, r"file 'f'")
 
518
        diff = self.get_diff(tree.basis_tree(), tree)
 
519
 
 
520
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
 
521
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
 
522
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
 
523
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
 
524
        self.assertNotContainsRe(diff, r"file 'e'")
 
525
        self.assertNotContainsRe(diff, r"file 'f'")
 
526
 
493
527
 
494
528
    def test_binary_unicode_filenames(self):
495
529
        """Test that contents of files are *not* encoded in UTF-8 when there
496
530
        is a binary file in the diff.
497
531
        """
498
532
        # See https://bugs.launchpad.net/bugs/110092.
499
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
533
        self.requireFeature(tests.UnicodeFilenameFeature)
500
534
 
501
535
        # This bug isn't triggered with cStringIO.
502
536
        from StringIO import StringIO
510
544
        tree.add([alpha], ['file-id'])
511
545
        tree.add([omega], ['file-id-2'])
512
546
        diff_content = StringIO()
513
 
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
514
 
        d = diff_content.getvalue()
515
 
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
516
 
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
517
 
                              % (alpha_utf8, alpha_utf8))
518
 
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
519
 
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
520
 
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
 
547
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
548
        diff = diff_content.getvalue()
 
549
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
550
        self.assertContainsRe(
 
551
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
552
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
553
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
554
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
521
555
 
522
556
    def test_unicode_filename(self):
523
557
        """Test when the filename are unicode."""
524
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
558
        self.requireFeature(tests.UnicodeFilenameFeature)
525
559
 
526
560
        alpha, omega = u'\u03b1', u'\u03c9'
527
561
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
542
576
        tree.add(['add_'+alpha], ['file-id'])
543
577
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
544
578
 
545
 
        d = get_diff_as_string(tree.basis_tree(), tree)
546
 
        self.assertContainsRe(d,
 
579
        diff = self.get_diff(tree.basis_tree(), tree)
 
580
        self.assertContainsRe(diff,
547
581
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
548
 
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
549
 
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
550
 
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
551
 
 
552
 
    def test_unicode_filename_path_encoding(self):
553
 
        """Test for bug #382699: unicode filenames on Windows should be shown
554
 
        in user encoding.
555
 
        """
556
 
        self.requireFeature(features.UnicodeFilenameFeature)
557
 
        # The word 'test' in Russian
558
 
        _russian_test = u'\u0422\u0435\u0441\u0442'
559
 
        directory = _russian_test + u'/'
560
 
        test_txt = _russian_test + u'.txt'
561
 
        u1234 = u'\u1234.txt'
562
 
 
563
 
        tree = self.make_branch_and_tree('.')
564
 
        self.build_tree_contents([
565
 
            (test_txt, 'foo\n'),
566
 
            (u1234, 'foo\n'),
567
 
            (directory, None),
568
 
            ])
569
 
        tree.add([test_txt, u1234, directory])
570
 
 
571
 
        sio = StringIO()
572
 
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
573
 
            path_encoding='cp1251')
574
 
 
575
 
        output = subst_dates(sio.getvalue())
576
 
        shouldbe = ('''\
577
 
=== added directory '%(directory)s'
578
 
=== added file '%(test_txt)s'
579
 
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
580
 
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
581
 
@@ -0,0 +1,1 @@
582
 
+foo
583
 
 
584
 
=== added file '?.txt'
585
 
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
586
 
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
587
 
@@ -0,0 +1,1 @@
588
 
+foo
589
 
 
590
 
''' % {'directory': _russian_test.encode('cp1251'),
591
 
       'test_txt': test_txt.encode('cp1251'),
592
 
      })
593
 
        self.assertEqualDiff(output, shouldbe)
594
 
 
595
 
 
596
 
class DiffWasIs(diff.DiffPath):
 
582
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
583
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
584
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
585
 
 
586
 
 
587
class DiffWasIs(DiffPath):
597
588
 
598
589
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
599
590
        self.to_file.write('was: ')
603
594
        pass
604
595
 
605
596
 
606
 
class TestDiffTree(tests.TestCaseWithTransport):
 
597
class TestDiffTree(TestCaseWithTransport):
607
598
 
608
599
    def setUp(self):
609
 
        super(TestDiffTree, self).setUp()
 
600
        TestCaseWithTransport.setUp(self)
610
601
        self.old_tree = self.make_branch_and_tree('old-tree')
611
602
        self.old_tree.lock_write()
612
603
        self.addCleanup(self.old_tree.unlock)
613
604
        self.new_tree = self.make_branch_and_tree('new-tree')
614
605
        self.new_tree.lock_write()
615
606
        self.addCleanup(self.new_tree.unlock)
616
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
607
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
617
608
 
618
609
    def test_diff_text(self):
619
610
        self.build_tree_contents([('old-tree/olddir/',),
624
615
                                  ('new-tree/newdir/newfile', 'new\n')])
625
616
        self.new_tree.add('newdir')
626
617
        self.new_tree.add('newdir/newfile', 'file-id')
627
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
618
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
628
619
        differ.diff_text('file-id', None, 'old label', 'new label')
629
620
        self.assertEqual(
630
621
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
659
650
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
660
651
 
661
652
    def test_diff_symlink(self):
662
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
653
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
663
654
        differ.diff_symlink('old target', None)
664
655
        self.assertEqual("=== target was 'old target'\n",
665
656
                         differ.to_file.getvalue())
666
657
 
667
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
658
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
668
659
        differ.diff_symlink(None, 'new target')
669
660
        self.assertEqual("=== target is 'new target'\n",
670
661
                         differ.to_file.getvalue())
671
662
 
672
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
663
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
673
664
        differ.diff_symlink('old target', 'new target')
674
665
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
675
666
                         differ.to_file.getvalue())
690
681
             ' \@\@\n-old\n\+new\n\n')
691
682
 
692
683
    def test_diff_kind_change(self):
693
 
        self.requireFeature(features.SymlinkFeature)
 
684
        self.requireFeature(tests.SymlinkFeature)
694
685
        self.build_tree_contents([('old-tree/olddir/',),
695
686
                                  ('old-tree/olddir/oldfile', 'old\n')])
696
687
        self.old_tree.add('olddir')
725
716
 
726
717
    def test_register_diff(self):
727
718
        self.create_old_new()
728
 
        old_diff_factories = diff.DiffTree.diff_factories
729
 
        diff.DiffTree.diff_factories=old_diff_factories[:]
730
 
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
719
        old_diff_factories = DiffTree.diff_factories
 
720
        DiffTree.diff_factories=old_diff_factories[:]
 
721
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
731
722
        try:
732
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
723
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
733
724
        finally:
734
 
            diff.DiffTree.diff_factories = old_diff_factories
 
725
            DiffTree.diff_factories = old_diff_factories
735
726
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
736
727
        self.assertNotContainsRe(
737
728
            differ.to_file.getvalue(),
742
733
 
743
734
    def test_extra_factories(self):
744
735
        self.create_old_new()
745
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
746
 
                               extra_factories=[DiffWasIs.from_diff_tree])
 
736
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
737
                            extra_factories=[DiffWasIs.from_diff_tree])
747
738
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
748
739
        self.assertNotContainsRe(
749
740
            differ.to_file.getvalue(),
762
753
            '.*a-file(.|\n)*b-file')
763
754
 
764
755
 
765
 
class TestPatienceDiffLib(tests.TestCase):
 
756
class TestPatienceDiffLib(TestCase):
766
757
 
767
758
    def setUp(self):
768
759
        super(TestPatienceDiffLib, self).setUp()
769
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
770
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
760
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
761
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
771
762
        self._PatienceSequenceMatcher = \
772
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
763
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
773
764
 
774
765
    def test_diff_unicode_string(self):
775
766
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
1082
1073
                 'how are you today?\n']
1083
1074
        txt_b = ['hello there\n',
1084
1075
                 'how are you today?\n']
1085
 
        unified_diff = patiencediff.unified_diff
 
1076
        unified_diff = bzrlib.patiencediff.unified_diff
1086
1077
        psm = self._PatienceSequenceMatcher
1087
1078
        self.assertEquals(['--- \n',
1088
1079
                           '+++ \n',
1136
1127
                 'how are you today?\n']
1137
1128
        txt_b = ['hello there\n',
1138
1129
                 'how are you today?\n']
1139
 
        unified_diff = patiencediff.unified_diff
 
1130
        unified_diff = bzrlib.patiencediff.unified_diff
1140
1131
        psm = self._PatienceSequenceMatcher
1141
1132
        self.assertEquals(['--- a\t2008-08-08\n',
1142
1133
                           '+++ b\t2008-09-09\n',
1154
1145
 
1155
1146
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1156
1147
 
1157
 
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1148
    _test_needs_features = [compiled_patiencediff_feature]
1158
1149
 
1159
1150
    def setUp(self):
1160
1151
        super(TestPatienceDiffLib_c, self).setUp()
1161
 
        from bzrlib import _patiencediff_c
1162
 
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1163
 
        self._recurse_matches = _patiencediff_c.recurse_matches_c
 
1152
        import bzrlib._patiencediff_c
 
1153
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1154
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
1164
1155
        self._PatienceSequenceMatcher = \
1165
 
            _patiencediff_c.PatienceSequenceMatcher_c
 
1156
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1166
1157
 
1167
1158
    def test_unhashable(self):
1168
1159
        """We should get a proper exception here."""
1178
1169
                                         None, ['valid'], ['valid', []])
1179
1170
 
1180
1171
 
1181
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1172
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1182
1173
 
1183
1174
    def setUp(self):
1184
1175
        super(TestPatienceDiffLibFiles, self).setUp()
1185
1176
        self._PatienceSequenceMatcher = \
1186
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
1177
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1187
1178
 
1188
1179
    def test_patience_unified_diff_files(self):
1189
1180
        txt_a = ['hello there\n',
1194
1185
        open('a1', 'wb').writelines(txt_a)
1195
1186
        open('b1', 'wb').writelines(txt_b)
1196
1187
 
1197
 
        unified_diff_files = patiencediff.unified_diff_files
 
1188
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1198
1189
        psm = self._PatienceSequenceMatcher
1199
1190
        self.assertEquals(['--- a1\n',
1200
1191
                           '+++ b1\n',
1250
1241
 
1251
1242
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1252
1243
 
1253
 
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1244
    _test_needs_features = [compiled_patiencediff_feature]
1254
1245
 
1255
1246
    def setUp(self):
1256
1247
        super(TestPatienceDiffLibFiles_c, self).setUp()
1257
 
        from bzrlib import _patiencediff_c
 
1248
        import bzrlib._patiencediff_c
1258
1249
        self._PatienceSequenceMatcher = \
1259
 
            _patiencediff_c.PatienceSequenceMatcher_c
1260
 
 
1261
 
 
1262
 
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1250
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1251
 
 
1252
 
 
1253
class TestUsingCompiledIfAvailable(TestCase):
1263
1254
 
1264
1255
    def test_PatienceSequenceMatcher(self):
1265
 
        if features.compiled_patiencediff_feature.available():
 
1256
        if compiled_patiencediff_feature.available():
1266
1257
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1267
1258
            self.assertIs(PatienceSequenceMatcher_c,
1268
 
                          patiencediff.PatienceSequenceMatcher)
 
1259
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1269
1260
        else:
1270
1261
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1271
1262
            self.assertIs(PatienceSequenceMatcher_py,
1272
 
                          patiencediff.PatienceSequenceMatcher)
 
1263
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1273
1264
 
1274
1265
    def test_unique_lcs(self):
1275
 
        if features.compiled_patiencediff_feature.available():
 
1266
        if compiled_patiencediff_feature.available():
1276
1267
            from bzrlib._patiencediff_c import unique_lcs_c
1277
1268
            self.assertIs(unique_lcs_c,
1278
 
                          patiencediff.unique_lcs)
 
1269
                          bzrlib.patiencediff.unique_lcs)
1279
1270
        else:
1280
1271
            from bzrlib._patiencediff_py import unique_lcs_py
1281
1272
            self.assertIs(unique_lcs_py,
1282
 
                          patiencediff.unique_lcs)
 
1273
                          bzrlib.patiencediff.unique_lcs)
1283
1274
 
1284
1275
    def test_recurse_matches(self):
1285
 
        if features.compiled_patiencediff_feature.available():
 
1276
        if compiled_patiencediff_feature.available():
1286
1277
            from bzrlib._patiencediff_c import recurse_matches_c
1287
1278
            self.assertIs(recurse_matches_c,
1288
 
                          patiencediff.recurse_matches)
 
1279
                          bzrlib.patiencediff.recurse_matches)
1289
1280
        else:
1290
1281
            from bzrlib._patiencediff_py import recurse_matches_py
1291
1282
            self.assertIs(recurse_matches_py,
1292
 
                          patiencediff.recurse_matches)
1293
 
 
1294
 
 
1295
 
class TestDiffFromTool(tests.TestCaseWithTransport):
 
1283
                          bzrlib.patiencediff.recurse_matches)
 
1284
 
 
1285
 
 
1286
class TestDiffFromTool(TestCaseWithTransport):
1296
1287
 
1297
1288
    def test_from_string(self):
1298
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
 
1289
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
1299
1290
        self.addCleanup(diff_obj.finish)
1300
1291
        self.assertEqual(['diff', '@old_path', '@new_path'],
1301
1292
            diff_obj.command_template)
1302
1293
 
1303
1294
    def test_from_string_u5(self):
1304
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1305
 
                                                 None, None, None)
 
1295
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
1306
1296
        self.addCleanup(diff_obj.finish)
1307
1297
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1308
1298
                         diff_obj.command_template)
1309
1299
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1310
1300
                         diff_obj._get_command('old-path', 'new-path'))
1311
1301
 
1312
 
    def test_from_string_path_with_backslashes(self):
1313
 
        self.requireFeature(features.backslashdir_feature)
1314
 
        tool = 'C:\\Tools\\Diff.exe'
1315
 
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1316
 
        self.addCleanup(diff_obj.finish)
1317
 
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1318
 
                         diff_obj.command_template)
1319
 
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
1320
 
                         diff_obj._get_command('old-path', 'new-path'))
1321
 
 
1322
1302
    def test_execute(self):
1323
1303
        output = StringIO()
1324
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1325
 
                                      'print "@old_path @new_path"'],
1326
 
                                     None, None, output)
 
1304
        diff_obj = DiffFromTool(['python', '-c',
 
1305
                                 'print "@old_path @new_path"'],
 
1306
                                None, None, output)
1327
1307
        self.addCleanup(diff_obj.finish)
1328
1308
        diff_obj._execute('old', 'new')
1329
1309
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1330
1310
 
1331
1311
    def test_excute_missing(self):
1332
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1333
 
                                     None, None, None)
 
1312
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1313
                                None, None, None)
1334
1314
        self.addCleanup(diff_obj.finish)
1335
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1336
 
                              'old', 'new')
 
1315
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
 
1316
                              'new')
1337
1317
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1338
1318
                         ' on this machine', str(e))
1339
1319
 
1340
1320
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1341
 
        self.requireFeature(features.AttribFeature)
 
1321
        self.requireFeature(AttribFeature)
1342
1322
        output = StringIO()
1343
1323
        tree = self.make_branch_and_tree('tree')
1344
1324
        self.build_tree_contents([('tree/file', 'content')])
1349
1329
        basis_tree = tree.basis_tree()
1350
1330
        basis_tree.lock_read()
1351
1331
        self.addCleanup(basis_tree.unlock)
1352
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1353
 
                                      'print "@old_path @new_path"'],
1354
 
                                     basis_tree, tree, output)
 
1332
        diff_obj = DiffFromTool(['python', '-c',
 
1333
                                 'print "@old_path @new_path"'],
 
1334
                                basis_tree, tree, output)
1355
1335
        diff_obj._prepare_files('file-id', 'file', 'file')
1356
1336
        # The old content should be readonly
1357
1337
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1374
1354
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1375
1355
        tree.add('oldname', 'file-id')
1376
1356
        tree.add('oldname2', 'file2-id')
1377
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1378
 
        tree.commit('old tree', timestamp=315532800)
 
1357
        tree.commit('old tree', timestamp=0)
1379
1358
        tree.rename_one('oldname', 'newname')
1380
1359
        tree.rename_one('oldname2', 'newname2')
1381
1360
        self.build_tree_contents([('tree/newname', 'newcontent')])
1385
1364
        self.addCleanup(old_tree.unlock)
1386
1365
        tree.lock_read()
1387
1366
        self.addCleanup(tree.unlock)
1388
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1389
 
                                      'print "@old_path @new_path"'],
1390
 
                                     old_tree, tree, output)
 
1367
        diff_obj = DiffFromTool(['python', '-c',
 
1368
                                 'print "@old_path @new_path"'],
 
1369
                                old_tree, tree, output)
1391
1370
        self.addCleanup(diff_obj.finish)
1392
1371
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1393
1372
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1394
1373
                                                     'newname')
1395
1374
        self.assertContainsRe(old_path, 'old/oldname$')
1396
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
 
1375
        self.assertEqual(0, os.stat(old_path).st_mtime)
1397
1376
        self.assertContainsRe(new_path, 'tree/newname$')
1398
1377
        self.assertFileEqual('oldcontent', old_path)
1399
1378
        self.assertFileEqual('newcontent', new_path)
1403
1382
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1404
1383
 
1405
1384
 
1406
 
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
1407
 
 
1408
 
    def test_encodable_filename(self):
1409
 
        # Just checks file path for external diff tool.
1410
 
        # We cannot change CPython's internal encoding used by os.exec*.
1411
 
        import sys
1412
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1413
 
                                    None, None, None)
1414
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1415
 
            encoding = scenario['encoding']
1416
 
            dirname  = scenario['info']['directory']
1417
 
            filename = scenario['info']['filename']
1418
 
 
1419
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1420
 
            relpath = dirname + u'/' + filename
1421
 
            fullpath = diffobj._safe_filename('safe', relpath)
1422
 
            self.assertEqual(
1423
 
                    fullpath,
1424
 
                    fullpath.encode(encoding).decode(encoding)
1425
 
                    )
1426
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1427
 
 
1428
 
    def test_unencodable_filename(self):
1429
 
        import sys
1430
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1431
 
                                    None, None, None)
1432
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1433
 
            encoding = scenario['encoding']
1434
 
            dirname  = scenario['info']['directory']
1435
 
            filename = scenario['info']['filename']
1436
 
 
1437
 
            if encoding == 'iso-8859-1':
1438
 
                encoding = 'iso-8859-2'
1439
 
            else:
1440
 
                encoding = 'iso-8859-1'
1441
 
 
1442
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1443
 
            relpath = dirname + u'/' + filename
1444
 
            fullpath = diffobj._safe_filename('safe', relpath)
1445
 
            self.assertEqual(
1446
 
                    fullpath,
1447
 
                    fullpath.encode(encoding).decode(encoding)
1448
 
                    )
1449
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
1450
 
 
1451
 
 
1452
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1453
 
 
1454
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1455
 
        """Call get_trees_and_branches_to_diff_locked."""
1456
 
        return diff.get_trees_and_branches_to_diff_locked(
1457
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
 
1385
class TestGetTreesAndBranchesToDiff(TestCaseWithTransport):
1458
1386
 
1459
1387
    def test_basic(self):
1460
1388
        tree = self.make_branch_and_tree('tree')
1461
1389
        (old_tree, new_tree,
1462
1390
         old_branch, new_branch,
1463
 
         specific_files, extra_trees) = self.call_gtabtd(
1464
 
             ['tree'], None, None, None)
 
1391
         specific_files, extra_trees) = \
 
1392
            get_trees_and_branches_to_diff(['tree'], None, None, None)
1465
1393
 
1466
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1467
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1468
 
                         old_tree.get_revision_id())
 
1394
        self.assertIsInstance(old_tree, RevisionTree)
 
1395
        #print dir (old_tree)
 
1396
        self.assertEqual(_mod_revision.NULL_REVISION, old_tree.get_revision_id())
1469
1397
        self.assertEqual(tree.basedir, new_tree.basedir)
1470
1398
        self.assertEqual(tree.branch.base, old_branch.base)
1471
1399
        self.assertEqual(tree.branch.base, new_branch.base)
1480
1408
        self.build_tree_contents([('tree/file', 'newcontent')])
1481
1409
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1482
1410
 
1483
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1484
 
                     revisionspec.RevisionSpec.from_string('2')]
 
1411
        revisions = [RevisionSpec.from_string('1'),
 
1412
                     RevisionSpec.from_string('2')]
1485
1413
        (old_tree, new_tree,
1486
1414
         old_branch, new_branch,
1487
 
         specific_files, extra_trees) = self.call_gtabtd(
1488
 
            ['tree'], revisions, None, None)
 
1415
         specific_files, extra_trees) = \
 
1416
            get_trees_and_branches_to_diff(['tree'], revisions, None, None)
1489
1417
 
1490
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1418
        self.assertIsInstance(old_tree, RevisionTree)
1491
1419
        self.assertEqual("old-id", old_tree.get_revision_id())
1492
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
 
1420
        self.assertIsInstance(new_tree, RevisionTree)
1493
1421
        self.assertEqual("new-id", new_tree.get_revision_id())
1494
1422
        self.assertEqual(tree.branch.base, old_branch.base)
1495
1423
        self.assertEqual(tree.branch.base, new_branch.base)