/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

Fix all tests broken by fixing make_branch_and_tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2010 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
 
import sys
21
 
import tempfile
 
22
from tempfile import TemporaryFile
22
23
 
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,
 
24
from bzrlib import tests
 
25
from bzrlib.diff import (
 
26
    DiffFromTool,
 
27
    DiffPath,
 
28
    DiffSymlink,
 
29
    DiffTree,
 
30
    DiffText,
 
31
    external_diff,
 
32
    internal_diff,
 
33
    show_diff_trees,
34
34
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import test_win32utils
37
 
 
38
 
 
39
 
class _AttribFeature(tests.Feature):
 
35
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
 
36
import bzrlib.osutils as osutils
 
37
import bzrlib.transform as transform
 
38
import bzrlib.patiencediff
 
39
import bzrlib._patiencediff_py
 
40
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
41
                          TestCaseInTempDir, TestSkipped)
 
42
 
 
43
 
 
44
class _CompiledPatienceDiffFeature(Feature):
40
45
 
41
46
    def _probe(self):
42
 
        if (sys.platform not in ('cygwin', 'win32')):
43
 
            return False
44
47
        try:
45
 
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
46
 
        except OSError, e:
 
48
            import bzrlib._patiencediff_c
 
49
        except ImportError:
47
50
            return False
48
 
        return (0 == proc.wait())
 
51
        return True
49
52
 
50
53
    def feature_name(self):
51
 
        return 'attrib Windows command-line tool'
52
 
 
53
 
AttribFeature = _AttribFeature()
54
 
 
55
 
 
56
 
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
57
 
                                    'bzrlib._patiencediff_c')
 
54
        return 'bzrlib._patiencediff_c'
 
55
 
 
56
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
58
57
 
59
58
 
60
59
def udiff_lines(old, new, allow_binary=False):
61
60
    output = StringIO()
62
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
61
    internal_diff('old', old, 'new', new, output, allow_binary)
63
62
    output.seek(0, 0)
64
63
    return output.readlines()
65
64
 
69
68
        # StringIO has no fileno, so it tests a different codepath
70
69
        output = StringIO()
71
70
    else:
72
 
        output = tempfile.TemporaryFile()
 
71
        output = TemporaryFile()
73
72
    try:
74
 
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
75
 
    except errors.NoDiff:
76
 
        raise tests.TestSkipped('external "diff" not present to test')
 
73
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
74
    except NoDiff:
 
75
        raise TestSkipped('external "diff" not present to test')
77
76
    output.seek(0, 0)
78
77
    lines = output.readlines()
79
78
    output.close()
80
79
    return lines
81
80
 
82
81
 
83
 
class TestDiff(tests.TestCase):
 
82
class TestDiff(TestCase):
84
83
 
85
84
    def test_add_nl(self):
86
85
        """diff generates a valid diff for patches that add a newline"""
122
121
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
123
122
 
124
123
    def test_binary_lines(self):
125
 
        empty = []
126
 
        uni_lines = [1023 * 'a' + '\x00']
127
 
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
128
 
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
129
 
        udiff_lines(uni_lines , empty, allow_binary=True)
130
 
        udiff_lines(empty, uni_lines, allow_binary=True)
 
124
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
125
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
126
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
127
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
131
128
 
132
129
    def test_external_diff(self):
133
130
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
163
160
        orig_path = os.environ['PATH']
164
161
        try:
165
162
            os.environ['PATH'] = ''
166
 
            self.assertRaises(errors.NoDiff, diff.external_diff,
 
163
            self.assertRaises(NoDiff, external_diff,
167
164
                              'old', ['boo\n'], 'new', ['goo\n'],
168
165
                              StringIO(), diff_opts=['-u'])
169
166
        finally:
170
167
            os.environ['PATH'] = orig_path
171
 
 
 
168
        
172
169
    def test_internal_diff_default(self):
173
170
        # Default internal diff encoding is utf8
174
171
        output = StringIO()
175
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
176
 
                           u'new_\xe5', ['new_text\n'], output)
 
172
        internal_diff(u'old_\xb5', ['old_text\n'],
 
173
                    u'new_\xe5', ['new_text\n'], output)
177
174
        lines = output.getvalue().splitlines(True)
178
175
        self.check_patch(lines)
179
176
        self.assertEquals(['--- old_\xc2\xb5\n',
187
184
 
188
185
    def test_internal_diff_utf8(self):
189
186
        output = StringIO()
190
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
191
 
                           u'new_\xe5', ['new_text\n'], output,
192
 
                           path_encoding='utf8')
 
187
        internal_diff(u'old_\xb5', ['old_text\n'],
 
188
                    u'new_\xe5', ['new_text\n'], output,
 
189
                    path_encoding='utf8')
193
190
        lines = output.getvalue().splitlines(True)
194
191
        self.check_patch(lines)
195
192
        self.assertEquals(['--- old_\xc2\xb5\n',
203
200
 
204
201
    def test_internal_diff_iso_8859_1(self):
205
202
        output = StringIO()
206
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
207
 
                           u'new_\xe5', ['new_text\n'], output,
208
 
                           path_encoding='iso-8859-1')
 
203
        internal_diff(u'old_\xb5', ['old_text\n'],
 
204
                    u'new_\xe5', ['new_text\n'], output,
 
205
                    path_encoding='iso-8859-1')
209
206
        lines = output.getvalue().splitlines(True)
210
207
        self.check_patch(lines)
211
208
        self.assertEquals(['--- old_\xb5\n',
219
216
 
220
217
    def test_internal_diff_no_content(self):
221
218
        output = StringIO()
222
 
        diff.internal_diff(u'old', [], u'new', [], output)
 
219
        internal_diff(u'old', [], u'new', [], output)
223
220
        self.assertEqual('', output.getvalue())
224
221
 
225
222
    def test_internal_diff_no_changes(self):
226
223
        output = StringIO()
227
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
228
 
                           u'new', ['text\n', 'contents\n'],
229
 
                           output)
 
224
        internal_diff(u'old', ['text\n', 'contents\n'],
 
225
                      u'new', ['text\n', 'contents\n'],
 
226
                      output)
230
227
        self.assertEqual('', output.getvalue())
231
228
 
232
229
    def test_internal_diff_returns_bytes(self):
233
230
        import StringIO
234
231
        output = StringIO.StringIO()
235
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
236
 
                            u'new_\xe5', ['new_text\n'], output)
 
232
        internal_diff(u'old_\xb5', ['old_text\n'],
 
233
                    u'new_\xe5', ['new_text\n'], output)
237
234
        self.failUnless(isinstance(output.getvalue(), str),
238
235
            'internal_diff should return bytestrings')
239
236
 
240
237
 
241
 
class TestDiffFiles(tests.TestCaseInTempDir):
 
238
class TestDiffFiles(TestCaseInTempDir):
242
239
 
243
240
    def test_external_diff_binary(self):
244
241
        """The output when using external diff should use diff's i18n error"""
257
254
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
258
255
 
259
256
 
260
 
class TestShowDiffTreesHelper(tests.TestCaseWithTransport):
 
257
class TestShowDiffTreesHelper(TestCaseWithTransport):
261
258
    """Has a helper for running show_diff_trees"""
262
259
 
263
260
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
266
263
            extra_trees = (working_tree,)
267
264
        else:
268
265
            extra_trees = ()
269
 
        diff.show_diff_trees(tree1, tree2, output,
270
 
                             specific_files=specific_files,
271
 
                             extra_trees=extra_trees, old_label='old/',
272
 
                             new_label='new/')
 
266
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
267
                        extra_trees=extra_trees, old_label='old/',
 
268
                        new_label='new/')
273
269
        return output.getvalue()
274
270
 
275
271
 
340
336
+file2 contents at rev 3
341
337
 
342
338
''')
343
 
 
 
339
        
344
340
    def test_diff_add_files(self):
345
 
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
 
341
        tree1 = self.b.repository.revision_tree(None)
346
342
        tree2 = self.b.repository.revision_tree('rev-1')
347
343
        output = self.get_diff(tree1, tree2)
348
344
        # the files have the epoch time stamp for the tree in which
382
378
        self.wt.rename_one('file1', 'file1b')
383
379
        old_tree = self.b.repository.revision_tree('rev-1')
384
380
        new_tree = self.b.repository.revision_tree('rev-4')
385
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
 
381
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
386
382
                            working_tree=self.wt)
387
383
        self.assertContainsRe(out, 'file1\t')
388
384
 
394
390
        self.wt.rename_one('file1', 'dir1/file1')
395
391
        old_tree = self.b.repository.revision_tree('rev-1')
396
392
        new_tree = self.b.repository.revision_tree('rev-4')
397
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
 
393
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
398
394
                            working_tree=self.wt)
399
395
        self.assertContainsRe(out, 'file1\t')
400
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
 
396
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
401
397
                            working_tree=self.wt)
402
398
        self.assertNotContainsRe(out, 'file1\t')
403
399
 
414
410
        tree.commit('one', rev_id='rev-1')
415
411
 
416
412
        self.build_tree_contents([('tree/file', 'new contents\n')])
417
 
        d = self.get_diff(tree.basis_tree(), tree)
418
 
        self.assertContainsRe(d, "=== modified file 'file'\n")
419
 
        self.assertContainsRe(d, '--- old/file\t')
420
 
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
421
 
        self.assertContainsRe(d, '-contents\n'
422
 
                                 '\\+new contents\n')
 
413
        diff = self.get_diff(tree.basis_tree(), tree)
 
414
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
415
        self.assertContainsRe(diff, '--- old/file\t')
 
416
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
417
        self.assertContainsRe(diff, '-contents\n'
 
418
                                    '\\+new contents\n')
423
419
 
424
420
    def test_modified_file_in_renamed_dir(self):
425
421
        """Test when a file is modified in a renamed directory."""
431
427
 
432
428
        tree.rename_one('dir', 'other')
433
429
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
434
 
        d = self.get_diff(tree.basis_tree(), tree)
435
 
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
436
 
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
430
        diff = self.get_diff(tree.basis_tree(), tree)
 
431
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
432
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
437
433
        # XXX: This is technically incorrect, because it used to be at another
438
434
        # location. What to do?
439
 
        self.assertContainsRe(d, '--- old/dir/file\t')
440
 
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
441
 
        self.assertContainsRe(d, '-contents\n'
442
 
                                 '\\+new contents\n')
 
435
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
436
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
437
        self.assertContainsRe(diff, '-contents\n'
 
438
                                    '\\+new contents\n')
443
439
 
444
440
    def test_renamed_directory(self):
445
441
        """Test when only a directory is only renamed."""
450
446
        tree.commit('one', rev_id='rev-1')
451
447
 
452
448
        tree.rename_one('dir', 'newdir')
453
 
        d = self.get_diff(tree.basis_tree(), tree)
 
449
        diff = self.get_diff(tree.basis_tree(), tree)
454
450
        # Renaming a directory should be a single "you renamed this dir" even
455
451
        # when there are files inside.
456
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
452
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
457
453
 
458
454
    def test_renamed_file(self):
459
455
        """Test when a file is only renamed."""
463
459
        tree.commit('one', rev_id='rev-1')
464
460
 
465
461
        tree.rename_one('file', 'newname')
466
 
        d = self.get_diff(tree.basis_tree(), tree)
467
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
462
        diff = self.get_diff(tree.basis_tree(), tree)
 
463
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
468
464
        # We shouldn't have a --- or +++ line, because there is no content
469
465
        # change
470
 
        self.assertNotContainsRe(d, '---')
 
466
        self.assertNotContainsRe(diff, '---')
471
467
 
472
468
    def test_renamed_and_modified_file(self):
473
469
        """Test when a file is only renamed."""
478
474
 
479
475
        tree.rename_one('file', 'newname')
480
476
        self.build_tree_contents([('tree/newname', 'new contents\n')])
481
 
        d = self.get_diff(tree.basis_tree(), tree)
482
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
483
 
        self.assertContainsRe(d, '--- old/file\t')
484
 
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
485
 
        self.assertContainsRe(d, '-contents\n'
486
 
                                 '\\+new contents\n')
 
477
        diff = self.get_diff(tree.basis_tree(), tree)
 
478
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
479
        self.assertContainsRe(diff, '--- old/file\t')
 
480
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
481
        self.assertContainsRe(diff, '-contents\n'
 
482
                                    '\\+new contents\n')
487
483
 
488
484
 
489
485
    def test_internal_diff_exec_property(self):
508
504
        tree.rename_one('c', 'new-c')
509
505
        tree.rename_one('d', 'new-d')
510
506
 
511
 
        d = self.get_diff(tree.basis_tree(), tree)
 
507
        diff = self.get_diff(tree.basis_tree(), tree)
512
508
 
513
 
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
514
 
                                  ".*\+x to -x.*\)")
515
 
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
516
 
                                  ".*-x to \+x.*\)")
517
 
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
518
 
                                  ".*\+x to -x.*\)")
519
 
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
520
 
                                  ".*-x to \+x.*\)")
521
 
        self.assertNotContainsRe(d, r"file 'e'")
522
 
        self.assertNotContainsRe(d, r"file 'f'")
 
509
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
 
510
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
 
511
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
 
512
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
 
513
        self.assertNotContainsRe(diff, r"file 'e'")
 
514
        self.assertNotContainsRe(diff, r"file 'f'")
523
515
 
524
516
 
525
517
    def test_binary_unicode_filenames(self):
541
533
        tree.add([alpha], ['file-id'])
542
534
        tree.add([omega], ['file-id-2'])
543
535
        diff_content = StringIO()
544
 
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
545
 
        d = diff_content.getvalue()
546
 
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
547
 
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
548
 
                              % (alpha_utf8, alpha_utf8))
549
 
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
550
 
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
551
 
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
 
536
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
537
        diff = diff_content.getvalue()
 
538
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
539
        self.assertContainsRe(
 
540
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
541
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
542
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
543
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
552
544
 
553
545
    def test_unicode_filename(self):
554
546
        """Test when the filename are unicode."""
573
565
        tree.add(['add_'+alpha], ['file-id'])
574
566
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
575
567
 
576
 
        d = self.get_diff(tree.basis_tree(), tree)
577
 
        self.assertContainsRe(d,
 
568
        diff = self.get_diff(tree.basis_tree(), tree)
 
569
        self.assertContainsRe(diff,
578
570
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
579
 
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
580
 
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
581
 
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
582
 
 
583
 
 
584
 
class DiffWasIs(diff.DiffPath):
 
571
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
572
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
573
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
574
 
 
575
 
 
576
class DiffWasIs(DiffPath):
585
577
 
586
578
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
587
579
        self.to_file.write('was: ')
591
583
        pass
592
584
 
593
585
 
594
 
class TestDiffTree(tests.TestCaseWithTransport):
 
586
class TestDiffTree(TestCaseWithTransport):
595
587
 
596
588
    def setUp(self):
597
 
        super(TestDiffTree, self).setUp()
 
589
        TestCaseWithTransport.setUp(self)
598
590
        self.old_tree = self.make_branch_and_tree('old-tree')
599
591
        self.old_tree.lock_write()
600
592
        self.addCleanup(self.old_tree.unlock)
601
593
        self.new_tree = self.make_branch_and_tree('new-tree')
602
594
        self.new_tree.lock_write()
603
595
        self.addCleanup(self.new_tree.unlock)
604
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
596
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
605
597
 
606
598
    def test_diff_text(self):
607
599
        self.build_tree_contents([('old-tree/olddir/',),
612
604
                                  ('new-tree/newdir/newfile', 'new\n')])
613
605
        self.new_tree.add('newdir')
614
606
        self.new_tree.add('newdir/newfile', 'file-id')
615
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
607
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
616
608
        differ.diff_text('file-id', None, 'old label', 'new label')
617
609
        self.assertEqual(
618
610
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
647
639
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
648
640
 
649
641
    def test_diff_symlink(self):
650
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
642
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
651
643
        differ.diff_symlink('old target', None)
652
644
        self.assertEqual("=== target was 'old target'\n",
653
645
                         differ.to_file.getvalue())
654
646
 
655
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
647
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
656
648
        differ.diff_symlink(None, 'new target')
657
649
        self.assertEqual("=== target is 'new target'\n",
658
650
                         differ.to_file.getvalue())
659
651
 
660
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
652
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
661
653
        differ.diff_symlink('old target', 'new target')
662
654
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
663
655
                         differ.to_file.getvalue())
693
685
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
694
686
             ' \@\@\n-old\n\n')
695
687
        self.assertContainsRe(self.differ.to_file.getvalue(),
696
 
                              "=== target is u'new'\n")
 
688
                              "=== target is 'new'\n")
697
689
 
698
690
    def test_diff_directory(self):
699
691
        self.build_tree(['new-tree/new-dir/'])
713
705
 
714
706
    def test_register_diff(self):
715
707
        self.create_old_new()
716
 
        old_diff_factories = diff.DiffTree.diff_factories
717
 
        diff.DiffTree.diff_factories=old_diff_factories[:]
718
 
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
708
        old_diff_factories = DiffTree.diff_factories
 
709
        DiffTree.diff_factories=old_diff_factories[:]
 
710
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
719
711
        try:
720
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
712
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
721
713
        finally:
722
 
            diff.DiffTree.diff_factories = old_diff_factories
 
714
            DiffTree.diff_factories = old_diff_factories
723
715
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
724
716
        self.assertNotContainsRe(
725
717
            differ.to_file.getvalue(),
730
722
 
731
723
    def test_extra_factories(self):
732
724
        self.create_old_new()
733
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
734
 
                               extra_factories=[DiffWasIs.from_diff_tree])
 
725
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
726
                            extra_factories=[DiffWasIs.from_diff_tree])
735
727
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
736
728
        self.assertNotContainsRe(
737
729
            differ.to_file.getvalue(),
750
742
            '.*a-file(.|\n)*b-file')
751
743
 
752
744
 
753
 
class TestPatienceDiffLib(tests.TestCase):
 
745
class TestPatienceDiffLib(TestCase):
754
746
 
755
747
    def setUp(self):
756
748
        super(TestPatienceDiffLib, self).setUp()
757
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
758
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
749
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
750
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
759
751
        self._PatienceSequenceMatcher = \
760
 
            _patiencediff_py.PatienceSequenceMatcher_py
761
 
 
762
 
    def test_diff_unicode_string(self):
763
 
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
764
 
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
765
 
        sm = self._PatienceSequenceMatcher(None, a, b)
766
 
        mb = sm.get_matching_blocks()
767
 
        self.assertEquals(35, len(mb))
 
752
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
768
753
 
769
754
    def test_unique_lcs(self):
770
755
        unique_lcs = self._unique_lcs
776
761
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
777
762
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
778
763
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
779
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
764
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
780
765
                                                         (3,3), (4,4)])
781
766
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
782
767
 
797
782
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
798
783
                                          (4, 6), (5, 7), (6, 8)])
799
784
 
800
 
        # recurse_matches doesn't match non-unique
 
785
        # recurse_matches doesn't match non-unique 
801
786
        # lines surrounded by bogus text.
802
787
        # The update has been done in patiencediff.SequenceMatcher instead
803
788
 
940
925
                 ('delete', 1,2, 1,1),
941
926
                 ('equal',  2,3, 1,2),
942
927
                ])
943
 
        chk_ops('aBccDe', 'abccde',
 
928
        chk_ops('aBccDe', 'abccde', 
944
929
                [('equal',   0,1, 0,1),
945
930
                 ('replace', 1,5, 1,5),
946
931
                 ('equal',   5,6, 5,6),
947
932
                ])
948
 
        chk_ops('aBcDec', 'abcdec',
 
933
        chk_ops('aBcDec', 'abcdec', 
949
934
                [('equal',   0,1, 0,1),
950
935
                 ('replace', 1,2, 1,2),
951
936
                 ('equal',   2,3, 2,3),
952
937
                 ('replace', 3,4, 3,4),
953
938
                 ('equal',   4,6, 4,6),
954
939
                ])
955
 
        chk_ops('aBcdEcdFg', 'abcdecdfg',
 
940
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
956
941
                [('equal',   0,1, 0,1),
957
942
                 ('replace', 1,8, 1,8),
958
943
                 ('equal',   8,9, 8,9)
959
944
                ])
960
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
 
945
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
961
946
                [('equal',   0,1, 0,1),
962
947
                 ('replace', 1,2, 1,2),
963
948
                 ('equal',   2,4, 2,4),
1023
1008
    """
1024
1009
    gnxrf_netf = ['svyr*']
1025
1010
    gnxrf_bcgvbaf = ['ab-erphefr']
1026
 
 
 
1011
  
1027
1012
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1028
1013
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1029
1014
        vs vf_dhvrg():
1037
1022
'''.splitlines(True), '''\
1038
1023
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1039
1024
 
1040
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
 
1025
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
1041
1026
    nqq gurz.
1042
1027
    """
1043
1028
    gnxrf_netf = ['svyr*']
1070
1055
                 'how are you today?\n']
1071
1056
        txt_b = ['hello there\n',
1072
1057
                 'how are you today?\n']
1073
 
        unified_diff = patiencediff.unified_diff
 
1058
        unified_diff = bzrlib.patiencediff.unified_diff
1074
1059
        psm = self._PatienceSequenceMatcher
1075
 
        self.assertEquals(['--- \n',
1076
 
                           '+++ \n',
 
1060
        self.assertEquals([ '---  \n',
 
1061
                           '+++  \n',
1077
1062
                           '@@ -1,3 +1,2 @@\n',
1078
1063
                           ' hello there\n',
1079
1064
                           '-world\n',
1084
1069
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1085
1070
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1086
1071
        # This is the result with LongestCommonSubstring matching
1087
 
        self.assertEquals(['--- \n',
1088
 
                           '+++ \n',
 
1072
        self.assertEquals(['---  \n',
 
1073
                           '+++  \n',
1089
1074
                           '@@ -1,6 +1,11 @@\n',
1090
1075
                           ' a\n',
1091
1076
                           ' b\n',
1100
1085
                           ' f\n']
1101
1086
                          , list(unified_diff(txt_a, txt_b)))
1102
1087
        # And the patience diff
1103
 
        self.assertEquals(['--- \n',
1104
 
                           '+++ \n',
 
1088
        self.assertEquals(['---  \n',
 
1089
                           '+++  \n',
1105
1090
                           '@@ -4,6 +4,11 @@\n',
1106
1091
                           ' d\n',
1107
1092
                           ' e\n',
1118
1103
                          , list(unified_diff(txt_a, txt_b,
1119
1104
                                 sequencematcher=psm)))
1120
1105
 
1121
 
    def test_patience_unified_diff_with_dates(self):
1122
 
        txt_a = ['hello there\n',
1123
 
                 'world\n',
1124
 
                 'how are you today?\n']
1125
 
        txt_b = ['hello there\n',
1126
 
                 'how are you today?\n']
1127
 
        unified_diff = patiencediff.unified_diff
1128
 
        psm = self._PatienceSequenceMatcher
1129
 
        self.assertEquals(['--- a\t2008-08-08\n',
1130
 
                           '+++ b\t2008-09-09\n',
1131
 
                           '@@ -1,3 +1,2 @@\n',
1132
 
                           ' hello there\n',
1133
 
                           '-world\n',
1134
 
                           ' how are you today?\n'
1135
 
                          ]
1136
 
                          , list(unified_diff(txt_a, txt_b,
1137
 
                                 fromfile='a', tofile='b',
1138
 
                                 fromfiledate='2008-08-08',
1139
 
                                 tofiledate='2008-09-09',
1140
 
                                 sequencematcher=psm)))
1141
 
 
1142
1106
 
1143
1107
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1144
1108
 
1145
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1109
    _test_needs_features = [CompiledPatienceDiffFeature]
1146
1110
 
1147
1111
    def setUp(self):
1148
1112
        super(TestPatienceDiffLib_c, self).setUp()
1149
 
        from bzrlib import _patiencediff_c
1150
 
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1151
 
        self._recurse_matches = _patiencediff_c.recurse_matches_c
 
1113
        import bzrlib._patiencediff_c
 
1114
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1115
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
1152
1116
        self._PatienceSequenceMatcher = \
1153
 
            _patiencediff_c.PatienceSequenceMatcher_c
 
1117
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1154
1118
 
1155
1119
    def test_unhashable(self):
1156
1120
        """We should get a proper exception here."""
1166
1130
                                         None, ['valid'], ['valid', []])
1167
1131
 
1168
1132
 
1169
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1133
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1170
1134
 
1171
1135
    def setUp(self):
1172
1136
        super(TestPatienceDiffLibFiles, self).setUp()
1173
1137
        self._PatienceSequenceMatcher = \
1174
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
1138
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1175
1139
 
1176
1140
    def test_patience_unified_diff_files(self):
1177
1141
        txt_a = ['hello there\n',
1182
1146
        open('a1', 'wb').writelines(txt_a)
1183
1147
        open('b1', 'wb').writelines(txt_b)
1184
1148
 
1185
 
        unified_diff_files = patiencediff.unified_diff_files
 
1149
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1186
1150
        psm = self._PatienceSequenceMatcher
1187
 
        self.assertEquals(['--- a1\n',
1188
 
                           '+++ b1\n',
 
1151
        self.assertEquals(['--- a1 \n',
 
1152
                           '+++ b1 \n',
1189
1153
                           '@@ -1,3 +1,2 @@\n',
1190
1154
                           ' hello there\n',
1191
1155
                           '-world\n',
1200
1164
        open('b2', 'wb').writelines(txt_b)
1201
1165
 
1202
1166
        # This is the result with LongestCommonSubstring matching
1203
 
        self.assertEquals(['--- a2\n',
1204
 
                           '+++ b2\n',
 
1167
        self.assertEquals(['--- a2 \n',
 
1168
                           '+++ b2 \n',
1205
1169
                           '@@ -1,6 +1,11 @@\n',
1206
1170
                           ' a\n',
1207
1171
                           ' b\n',
1217
1181
                          , list(unified_diff_files('a2', 'b2')))
1218
1182
 
1219
1183
        # And the patience diff
1220
 
        self.assertEquals(['--- a2\n',
1221
 
                           '+++ b2\n',
 
1184
        self.assertEquals(['--- a2 \n',
 
1185
                           '+++ b2 \n',
1222
1186
                           '@@ -4,6 +4,11 @@\n',
1223
1187
                           ' d\n',
1224
1188
                           ' e\n',
1238
1202
 
1239
1203
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1240
1204
 
1241
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1205
    _test_needs_features = [CompiledPatienceDiffFeature]
1242
1206
 
1243
1207
    def setUp(self):
1244
1208
        super(TestPatienceDiffLibFiles_c, self).setUp()
1245
 
        from bzrlib import _patiencediff_c
 
1209
        import bzrlib._patiencediff_c
1246
1210
        self._PatienceSequenceMatcher = \
1247
 
            _patiencediff_c.PatienceSequenceMatcher_c
1248
 
 
1249
 
 
1250
 
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1211
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1212
 
 
1213
 
 
1214
class TestUsingCompiledIfAvailable(TestCase):
1251
1215
 
1252
1216
    def test_PatienceSequenceMatcher(self):
1253
 
        if compiled_patiencediff_feature.available():
 
1217
        if CompiledPatienceDiffFeature.available():
1254
1218
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1255
1219
            self.assertIs(PatienceSequenceMatcher_c,
1256
 
                          patiencediff.PatienceSequenceMatcher)
 
1220
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1257
1221
        else:
1258
1222
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1259
1223
            self.assertIs(PatienceSequenceMatcher_py,
1260
 
                          patiencediff.PatienceSequenceMatcher)
 
1224
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1261
1225
 
1262
1226
    def test_unique_lcs(self):
1263
 
        if compiled_patiencediff_feature.available():
 
1227
        if CompiledPatienceDiffFeature.available():
1264
1228
            from bzrlib._patiencediff_c import unique_lcs_c
1265
1229
            self.assertIs(unique_lcs_c,
1266
 
                          patiencediff.unique_lcs)
 
1230
                          bzrlib.patiencediff.unique_lcs)
1267
1231
        else:
1268
1232
            from bzrlib._patiencediff_py import unique_lcs_py
1269
1233
            self.assertIs(unique_lcs_py,
1270
 
                          patiencediff.unique_lcs)
 
1234
                          bzrlib.patiencediff.unique_lcs)
1271
1235
 
1272
1236
    def test_recurse_matches(self):
1273
 
        if compiled_patiencediff_feature.available():
 
1237
        if CompiledPatienceDiffFeature.available():
1274
1238
            from bzrlib._patiencediff_c import recurse_matches_c
1275
1239
            self.assertIs(recurse_matches_c,
1276
 
                          patiencediff.recurse_matches)
 
1240
                          bzrlib.patiencediff.recurse_matches)
1277
1241
        else:
1278
1242
            from bzrlib._patiencediff_py import recurse_matches_py
1279
1243
            self.assertIs(recurse_matches_py,
1280
 
                          patiencediff.recurse_matches)
1281
 
 
1282
 
 
1283
 
class TestDiffFromTool(tests.TestCaseWithTransport):
 
1244
                          bzrlib.patiencediff.recurse_matches)
 
1245
 
 
1246
 
 
1247
class TestDiffFromTool(TestCaseWithTransport):
1284
1248
 
1285
1249
    def test_from_string(self):
1286
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
 
1250
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
1287
1251
        self.addCleanup(diff_obj.finish)
1288
 
        self.assertEqual(['diff', '@old_path', '@new_path'],
 
1252
        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],
1289
1253
            diff_obj.command_template)
1290
1254
 
1291
1255
    def test_from_string_u5(self):
1292
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1293
 
                                                 None, None, None)
 
1256
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
1294
1257
        self.addCleanup(diff_obj.finish)
1295
 
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
 
1258
        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],
1296
1259
                         diff_obj.command_template)
1297
1260
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1298
1261
                         diff_obj._get_command('old-path', 'new-path'))
1299
1262
 
1300
 
    def test_from_string_path_with_backslashes(self):
1301
 
        self.requireFeature(test_win32utils.BackslashDirSeparatorFeature)
1302
 
        tool = 'C:\\Tools\\Diff.exe'
1303
 
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1304
 
        self.addCleanup(diff_obj.finish)
1305
 
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1306
 
                         diff_obj.command_template)
1307
 
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
1308
 
                         diff_obj._get_command('old-path', 'new-path'))
1309
 
 
1310
1263
    def test_execute(self):
1311
1264
        output = StringIO()
1312
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1313
 
                                      'print "@old_path @new_path"'],
1314
 
                                     None, None, output)
 
1265
        diff_obj = DiffFromTool(['python', '-c',
 
1266
                                 'print "%(old_path)s %(new_path)s"'],
 
1267
                                None, None, output)
1315
1268
        self.addCleanup(diff_obj.finish)
1316
1269
        diff_obj._execute('old', 'new')
1317
1270
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1318
1271
 
1319
1272
    def test_excute_missing(self):
1320
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1321
 
                                     None, None, None)
 
1273
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1274
                                None, None, None)
1322
1275
        self.addCleanup(diff_obj.finish)
1323
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1324
 
                              'old', 'new')
 
1276
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
 
1277
                              'new')
1325
1278
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1326
1279
                         ' on this machine', str(e))
1327
1280
 
1328
 
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1329
 
        self.requireFeature(AttribFeature)
1330
 
        output = StringIO()
1331
 
        tree = self.make_branch_and_tree('tree')
1332
 
        self.build_tree_contents([('tree/file', 'content')])
1333
 
        tree.add('file', 'file-id')
1334
 
        tree.commit('old tree')
1335
 
        tree.lock_read()
1336
 
        self.addCleanup(tree.unlock)
1337
 
        basis_tree = tree.basis_tree()
1338
 
        basis_tree.lock_read()
1339
 
        self.addCleanup(basis_tree.unlock)
1340
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1341
 
                                      'print "@old_path @new_path"'],
1342
 
                                     basis_tree, tree, output)
1343
 
        diff_obj._prepare_files('file-id', 'file', 'file')
1344
 
        # The old content should be readonly
1345
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1346
 
                                    r'R.*old\\file$')
1347
 
        # The new content should use the tree object, not a 'new' file anymore
1348
 
        self.assertEndsWith(tree.basedir, 'work/tree')
1349
 
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1350
 
 
1351
 
    def assertReadableByAttrib(self, cwd, relpath, regex):
1352
 
        proc = subprocess.Popen(['attrib', relpath],
1353
 
                                stdout=subprocess.PIPE,
1354
 
                                cwd=cwd)
1355
 
        (result, err) = proc.communicate()
1356
 
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1357
 
 
1358
1281
    def test_prepare_files(self):
1359
1282
        output = StringIO()
1360
1283
        tree = self.make_branch_and_tree('tree')
1361
1284
        self.build_tree_contents([('tree/oldname', 'oldcontent')])
1362
 
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1363
1285
        tree.add('oldname', 'file-id')
1364
 
        tree.add('oldname2', 'file2-id')
1365
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1366
 
        tree.commit('old tree', timestamp=315532800)
 
1286
        tree.commit('old tree', timestamp=0)
1367
1287
        tree.rename_one('oldname', 'newname')
1368
 
        tree.rename_one('oldname2', 'newname2')
1369
1288
        self.build_tree_contents([('tree/newname', 'newcontent')])
1370
 
        self.build_tree_contents([('tree/newname2', 'newcontent2')])
1371
1289
        old_tree = tree.basis_tree()
1372
1290
        old_tree.lock_read()
1373
1291
        self.addCleanup(old_tree.unlock)
1374
1292
        tree.lock_read()
1375
1293
        self.addCleanup(tree.unlock)
1376
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1377
 
                                      'print "@old_path @new_path"'],
1378
 
                                     old_tree, tree, output)
 
1294
        diff_obj = DiffFromTool(['python', '-c',
 
1295
                                 'print "%(old_path)s %(new_path)s"'],
 
1296
                                old_tree, tree, output)
1379
1297
        self.addCleanup(diff_obj.finish)
1380
1298
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1381
1299
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1382
1300
                                                     'newname')
1383
1301
        self.assertContainsRe(old_path, 'old/oldname$')
1384
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
1385
 
        self.assertContainsRe(new_path, 'tree/newname$')
 
1302
        self.assertEqual(0, os.stat(old_path).st_mtime)
 
1303
        self.assertContainsRe(new_path, 'new/newname$')
1386
1304
        self.assertFileEqual('oldcontent', old_path)
1387
1305
        self.assertFileEqual('newcontent', new_path)
1388
 
        if osutils.host_os_dereferences_symlinks():
 
1306
        if osutils.has_symlinks():
1389
1307
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1390
1308
        # make sure we can create files with the same parent directories
1391
 
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1392
 
 
1393
 
 
1394
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1395
 
 
1396
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1397
 
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
1398
 
        TestGetTreesAndBranchesToDiff.
1399
 
        """
1400
 
        return diff.get_trees_and_branches_to_diff_locked(
1401
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1402
 
 
1403
 
    def test_basic(self):
1404
 
        tree = self.make_branch_and_tree('tree')
1405
 
        (old_tree, new_tree,
1406
 
         old_branch, new_branch,
1407
 
         specific_files, extra_trees) = self.call_gtabtd(
1408
 
             ['tree'], None, None, None)
1409
 
 
1410
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1411
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1412
 
                         old_tree.get_revision_id())
1413
 
        self.assertEqual(tree.basedir, new_tree.basedir)
1414
 
        self.assertEqual(tree.branch.base, old_branch.base)
1415
 
        self.assertEqual(tree.branch.base, new_branch.base)
1416
 
        self.assertIs(None, specific_files)
1417
 
        self.assertIs(None, extra_trees)
1418
 
 
1419
 
    def test_with_rev_specs(self):
1420
 
        tree = self.make_branch_and_tree('tree')
1421
 
        self.build_tree_contents([('tree/file', 'oldcontent')])
1422
 
        tree.add('file', 'file-id')
1423
 
        tree.commit('old tree', timestamp=0, rev_id="old-id")
1424
 
        self.build_tree_contents([('tree/file', 'newcontent')])
1425
 
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1426
 
 
1427
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1428
 
                     revisionspec.RevisionSpec.from_string('2')]
1429
 
        (old_tree, new_tree,
1430
 
         old_branch, new_branch,
1431
 
         specific_files, extra_trees) = self.call_gtabtd(
1432
 
            ['tree'], revisions, None, None)
1433
 
 
1434
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1435
 
        self.assertEqual("old-id", old_tree.get_revision_id())
1436
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
1437
 
        self.assertEqual("new-id", new_tree.get_revision_id())
1438
 
        self.assertEqual(tree.branch.base, old_branch.base)
1439
 
        self.assertEqual(tree.branch.base, new_branch.base)
1440
 
        self.assertIs(None, specific_files)
1441
 
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
1442
 
 
1443
 
 
1444
 
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
1445
 
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
1446
 
    deprecated get_trees_and_branches_to_diff function.
1447
 
    """
1448
 
 
1449
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1450
 
        return self.applyDeprecated(
1451
 
            deprecated_in((2, 2, 0)), diff.get_trees_and_branches_to_diff,
1452
 
            path_list, revision_specs, old_url, new_url)
1453
 
 
 
1309
        diff_obj._prepare_files('file-id', 'oldname2', 'newname2')