← 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: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2014, 2016, 2017 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
19
18
from cStringIO import StringIO
20
 
import errno
21
19
import subprocess
22
 
import sys
23
 
from tempfile import TemporaryFile
 
20
import tempfile
24
21
 
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,
 
22
from bzrlib import (
 
23
    diff,
 
24
    errors,
 
25
    osutils,
 
26
    patiencediff,
 
27
    _patiencediff_py,
 
28
    revision as _mod_revision,
 
29
    revisionspec,
 
30
    revisiontree,
 
31
    tests,
 
32
    transform,
35
33
    )
36
 
from bzrlib.errors import BinaryFile, NoDiff, ExecutableMissing
37
 
import bzrlib.osutils as osutils
38
 
import bzrlib.revision as _mod_revision
39
 
import bzrlib.transform as transform
40
 
import bzrlib.patiencediff
41
 
import bzrlib._patiencediff_py
42
 
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
43
 
                          TestCaseInTempDir, TestSkipped)
44
 
 
45
 
 
46
 
class _AttribFeature(Feature):
47
 
 
48
 
    def _probe(self):
49
 
        if (sys.platform not in ('cygwin', 'win32')):
50
 
            return False
51
 
        try:
52
 
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
53
 
        except OSError, e:
54
 
            return False
55
 
        return (0 == proc.wait())
56
 
 
57
 
    def feature_name(self):
58
 
        return 'attrib Windows command-line tool'
59
 
 
60
 
AttribFeature = _AttribFeature()
61
 
 
62
 
 
63
 
class _CompiledPatienceDiffFeature(Feature):
64
 
 
65
 
    def _probe(self):
66
 
        try:
67
 
            import bzrlib._patiencediff_c
68
 
        except ImportError:
69
 
            return False
70
 
        return True
71
 
 
72
 
    def feature_name(self):
73
 
        return 'bzrlib._patiencediff_c'
74
 
 
75
 
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
 
34
from bzrlib.tests import (
 
35
    features,
 
36
    EncodingAdapter,
 
37
)
 
38
from bzrlib.tests.blackbox.test_diff import subst_dates
 
39
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
40
 
 
41
 
 
42
load_tests = load_tests_apply_scenarios
76
43
 
77
44
 
78
45
def udiff_lines(old, new, allow_binary=False):
79
46
    output = StringIO()
80
 
    internal_diff('old', old, 'new', new, output, allow_binary)
 
47
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
81
48
    output.seek(0, 0)
82
49
    return output.readlines()
83
50
 
87
54
        # StringIO has no fileno, so it tests a different codepath
88
55
        output = StringIO()
89
56
    else:
90
 
        output = TemporaryFile()
 
57
        output = tempfile.TemporaryFile()
91
58
    try:
92
 
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
93
 
    except NoDiff:
94
 
        raise TestSkipped('external "diff" not present to test')
 
59
        diff.external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
60
    except errors.NoDiff:
 
61
        raise tests.TestSkipped('external "diff" not present to test')
95
62
    output.seek(0, 0)
96
63
    lines = output.readlines()
97
64
    output.close()
98
65
    return lines
99
66
 
100
67
 
101
 
class TestDiff(TestCase):
 
68
class TestDiffOptions(tests.TestCase):
 
69
 
 
70
    def test_unified_added(self):
 
71
        """Check for default style '-u' only if no other style specified
 
72
        in 'diff-options'.
 
73
        """
 
74
        # Verify that style defaults to unified, id est '-u' appended
 
75
        # to option list, in the absence of an alternative style.
 
76
        self.assertEqual(['-a', '-u'], diff.default_style_unified(['-a']))
 
77
 
 
78
 
 
79
class TestDiffOptionsScenarios(tests.TestCase):
 
80
 
 
81
    scenarios = [(s, dict(style=s)) for s in diff.style_option_list]
 
82
    style = None # Set by load_tests_apply_scenarios from scenarios
 
83
 
 
84
    def test_unified_not_added(self):
 
85
        # Verify that for all valid style options, '-u' is not
 
86
        # appended to option list.
 
87
        ret_opts = diff.default_style_unified(diff_opts=["%s" % (self.style,)])
 
88
        self.assertEqual(["%s" % (self.style,)], ret_opts)
 
89
 
 
90
 
 
91
class TestDiff(tests.TestCase):
102
92
 
103
93
    def test_add_nl(self):
104
94
        """diff generates a valid diff for patches that add a newline"""
105
95
        lines = udiff_lines(['boo'], ['boo\n'])
106
96
        self.check_patch(lines)
107
 
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
 
97
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
108
98
            ## "expected no-nl, got %r" % lines[4]
109
99
 
110
100
    def test_add_nl_2(self):
113
103
        """
114
104
        lines = udiff_lines(['boo'], ['goo\n'])
115
105
        self.check_patch(lines)
116
 
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
 
106
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
117
107
            ## "expected no-nl, got %r" % lines[4]
118
108
 
119
109
    def test_remove_nl(self):
122
112
        """
123
113
        lines = udiff_lines(['boo\n'], ['boo'])
124
114
        self.check_patch(lines)
125
 
        self.assertEquals(lines[5], '\\ No newline at end of file\n')
 
115
        self.assertEqual(lines[5], '\\ No newline at end of file\n')
126
116
            ## "expected no-nl, got %r" % lines[5]
127
117
 
128
118
    def check_patch(self, lines):
129
 
        self.assert_(len(lines) > 1)
 
119
        self.assertTrue(len(lines) > 1)
130
120
            ## "Not enough lines for a file header for patch:\n%s" % "".join(lines)
131
 
        self.assert_(lines[0].startswith ('---'))
 
121
        self.assertTrue(lines[0].startswith ('---'))
132
122
            ## 'No orig line for patch:\n%s' % "".join(lines)
133
 
        self.assert_(lines[1].startswith ('+++'))
 
123
        self.assertTrue(lines[1].startswith ('+++'))
134
124
            ## 'No mod line for patch:\n%s' % "".join(lines)
135
 
        self.assert_(len(lines) > 2)
 
125
        self.assertTrue(len(lines) > 2)
136
126
            ## "No hunks for patch:\n%s" % "".join(lines)
137
 
        self.assert_(lines[2].startswith('@@'))
 
127
        self.assertTrue(lines[2].startswith('@@'))
138
128
            ## "No hunk header for patch:\n%s" % "".join(lines)
139
 
        self.assert_('@@' in lines[2][2:])
 
129
        self.assertTrue('@@' in lines[2][2:])
140
130
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
141
131
 
142
132
    def test_binary_lines(self):
143
 
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
144
 
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
145
 
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
146
 
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
 
133
        empty = []
 
134
        uni_lines = [1023 * 'a' + '\x00']
 
135
        self.assertRaises(errors.BinaryFile, udiff_lines, uni_lines , empty)
 
136
        self.assertRaises(errors.BinaryFile, udiff_lines, empty, uni_lines)
 
137
        udiff_lines(uni_lines , empty, allow_binary=True)
 
138
        udiff_lines(empty, uni_lines, allow_binary=True)
147
139
 
148
140
    def test_external_diff(self):
149
141
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
159
151
        self.check_patch(lines)
160
152
 
161
153
    def test_external_diff_binary_lang_c(self):
162
 
        old_env = {}
163
154
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
164
 
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
165
 
        try:
166
 
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
167
 
            # Older versions of diffutils say "Binary files", newer
168
 
            # versions just say "Files".
169
 
            self.assertContainsRe(lines[0],
170
 
                                  '(Binary f|F)iles old and new differ\n')
171
 
            self.assertEquals(lines[1:], ['\n'])
172
 
        finally:
173
 
            for lang, old_val in old_env.iteritems():
174
 
                osutils.set_or_unset_env(lang, old_val)
 
155
            self.overrideEnv(lang, 'C')
 
156
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
157
        # Older versions of diffutils say "Binary files", newer
 
158
        # versions just say "Files".
 
159
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
 
160
        self.assertEqual(lines[1:], ['\n'])
175
161
 
176
162
    def test_no_external_diff(self):
177
163
        """Check that NoDiff is raised when diff is not available"""
178
 
        # Use os.environ['PATH'] to make sure no 'diff' command is available
179
 
        orig_path = os.environ['PATH']
180
 
        try:
181
 
            os.environ['PATH'] = ''
182
 
            self.assertRaises(NoDiff, external_diff,
183
 
                              'old', ['boo\n'], 'new', ['goo\n'],
184
 
                              StringIO(), diff_opts=['-u'])
185
 
        finally:
186
 
            os.environ['PATH'] = orig_path
 
164
        # Make sure no 'diff' command is available
 
165
        # XXX: Weird, using None instead of '' breaks the test -- vila 20101216
 
166
        self.overrideEnv('PATH', '')
 
167
        self.assertRaises(errors.NoDiff, diff.external_diff,
 
168
                          'old', ['boo\n'], 'new', ['goo\n'],
 
169
                          StringIO(), diff_opts=['-u'])
187
170
 
188
171
    def test_internal_diff_default(self):
189
172
        # Default internal diff encoding is utf8
190
173
        output = StringIO()
191
 
        internal_diff(u'old_\xb5', ['old_text\n'],
192
 
                    u'new_\xe5', ['new_text\n'], output)
 
174
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
175
                           u'new_\xe5', ['new_text\n'], output)
193
176
        lines = output.getvalue().splitlines(True)
194
177
        self.check_patch(lines)
195
 
        self.assertEquals(['--- old_\xc2\xb5\n',
 
178
        self.assertEqual(['--- old_\xc2\xb5\n',
196
179
                           '+++ new_\xc3\xa5\n',
197
180
                           '@@ -1,1 +1,1 @@\n',
198
181
                           '-old_text\n',
203
186
 
204
187
    def test_internal_diff_utf8(self):
205
188
        output = StringIO()
206
 
        internal_diff(u'old_\xb5', ['old_text\n'],
207
 
                    u'new_\xe5', ['new_text\n'], output,
208
 
                    path_encoding='utf8')
 
189
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
190
                           u'new_\xe5', ['new_text\n'], output,
 
191
                           path_encoding='utf8')
209
192
        lines = output.getvalue().splitlines(True)
210
193
        self.check_patch(lines)
211
 
        self.assertEquals(['--- old_\xc2\xb5\n',
 
194
        self.assertEqual(['--- old_\xc2\xb5\n',
212
195
                           '+++ new_\xc3\xa5\n',
213
196
                           '@@ -1,1 +1,1 @@\n',
214
197
                           '-old_text\n',
219
202
 
220
203
    def test_internal_diff_iso_8859_1(self):
221
204
        output = StringIO()
222
 
        internal_diff(u'old_\xb5', ['old_text\n'],
223
 
                    u'new_\xe5', ['new_text\n'], output,
224
 
                    path_encoding='iso-8859-1')
 
205
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
206
                           u'new_\xe5', ['new_text\n'], output,
 
207
                           path_encoding='iso-8859-1')
225
208
        lines = output.getvalue().splitlines(True)
226
209
        self.check_patch(lines)
227
 
        self.assertEquals(['--- old_\xb5\n',
 
210
        self.assertEqual(['--- old_\xb5\n',
228
211
                           '+++ new_\xe5\n',
229
212
                           '@@ -1,1 +1,1 @@\n',
230
213
                           '-old_text\n',
235
218
 
236
219
    def test_internal_diff_no_content(self):
237
220
        output = StringIO()
238
 
        internal_diff(u'old', [], u'new', [], output)
 
221
        diff.internal_diff(u'old', [], u'new', [], output)
239
222
        self.assertEqual('', output.getvalue())
240
223
 
241
224
    def test_internal_diff_no_changes(self):
242
225
        output = StringIO()
243
 
        internal_diff(u'old', ['text\n', 'contents\n'],
244
 
                      u'new', ['text\n', 'contents\n'],
245
 
                      output)
 
226
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
 
227
                           u'new', ['text\n', 'contents\n'],
 
228
                           output)
246
229
        self.assertEqual('', output.getvalue())
247
230
 
248
231
    def test_internal_diff_returns_bytes(self):
249
232
        import StringIO
250
233
        output = StringIO.StringIO()
251
 
        internal_diff(u'old_\xb5', ['old_text\n'],
252
 
                    u'new_\xe5', ['new_text\n'], output)
253
 
        self.failUnless(isinstance(output.getvalue(), str),
 
234
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
 
235
                            u'new_\xe5', ['new_text\n'], output)
 
236
        self.assertIsInstance(output.getvalue(), str,
254
237
            'internal_diff should return bytestrings')
255
238
 
256
 
 
257
 
class TestDiffFiles(TestCaseInTempDir):
 
239
    def test_internal_diff_default_context(self):
 
240
        output = StringIO()
 
241
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
242
                           'same_text\n','same_text\n','old_text\n'],
 
243
                           'new', ['same_text\n','same_text\n','same_text\n',
 
244
                           'same_text\n','same_text\n','new_text\n'], output)
 
245
        lines = output.getvalue().splitlines(True)
 
246
        self.check_patch(lines)
 
247
        self.assertEqual(['--- old\n',
 
248
                           '+++ new\n',
 
249
                           '@@ -3,4 +3,4 @@\n',
 
250
                           ' same_text\n',
 
251
                           ' same_text\n',
 
252
                           ' same_text\n',
 
253
                           '-old_text\n',
 
254
                           '+new_text\n',
 
255
                           '\n',
 
256
                          ]
 
257
                          , lines)
 
258
 
 
259
    def test_internal_diff_no_context(self):
 
260
        output = StringIO()
 
261
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
262
                           'same_text\n','same_text\n','old_text\n'],
 
263
                           'new', ['same_text\n','same_text\n','same_text\n',
 
264
                           'same_text\n','same_text\n','new_text\n'], output,
 
265
                           context_lines=0)
 
266
        lines = output.getvalue().splitlines(True)
 
267
        self.check_patch(lines)
 
268
        self.assertEqual(['--- old\n',
 
269
                           '+++ new\n',
 
270
                           '@@ -6,1 +6,1 @@\n',
 
271
                           '-old_text\n',
 
272
                           '+new_text\n',
 
273
                           '\n',
 
274
                          ]
 
275
                          , lines)
 
276
 
 
277
    def test_internal_diff_more_context(self):
 
278
        output = StringIO()
 
279
        diff.internal_diff('old', ['same_text\n','same_text\n','same_text\n',
 
280
                           'same_text\n','same_text\n','old_text\n'],
 
281
                           'new', ['same_text\n','same_text\n','same_text\n',
 
282
                           'same_text\n','same_text\n','new_text\n'], output,
 
283
                           context_lines=4)
 
284
        lines = output.getvalue().splitlines(True)
 
285
        self.check_patch(lines)
 
286
        self.assertEqual(['--- old\n',
 
287
                           '+++ new\n',
 
288
                           '@@ -2,5 +2,5 @@\n',
 
289
                           ' same_text\n',
 
290
                           ' same_text\n',
 
291
                           ' same_text\n',
 
292
                           ' same_text\n',
 
293
                           '-old_text\n',
 
294
                           '+new_text\n',
 
295
                           '\n',
 
296
                          ]
 
297
                          , lines)
 
298
 
 
299
 
 
300
 
 
301
 
 
302
 
 
303
class TestDiffFiles(tests.TestCaseInTempDir):
258
304
 
259
305
    def test_external_diff_binary(self):
260
306
        """The output when using external diff should use diff's i18n error"""
262
308
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
263
309
 
264
310
        cmd = ['diff', '-u', '--binary', 'old', 'new']
265
 
        open('old', 'wb').write('\x00foobar\n')
266
 
        open('new', 'wb').write('foo\x00bar\n')
 
311
        with open('old', 'wb') as f: f.write('\x00foobar\n')
 
312
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
267
313
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
268
314
                                     stdin=subprocess.PIPE)
269
315
        out, err = pipe.communicate()
270
 
        # Diff returns '2' on Binary files.
271
 
        self.assertEqual(2, pipe.returncode)
272
316
        # We should output whatever diff tells us, plus a trailing newline
273
317
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
274
318
 
275
319
 
276
 
class TestShowDiffTreesHelper(TestCaseWithTransport):
277
 
    """Has a helper for running show_diff_trees"""
278
 
 
279
 
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
280
 
        output = StringIO()
281
 
        if working_tree is not None:
282
 
            extra_trees = (working_tree,)
283
 
        else:
284
 
            extra_trees = ()
285
 
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
286
 
                        extra_trees=extra_trees, old_label='old/',
287
 
                        new_label='new/')
288
 
        return output.getvalue()
289
 
 
290
 
 
291
 
class TestDiffDates(TestShowDiffTreesHelper):
 
320
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
 
321
    output = StringIO()
 
322
    if working_tree is not None:
 
323
        extra_trees = (working_tree,)
 
324
    else:
 
325
        extra_trees = ()
 
326
    diff.show_diff_trees(tree1, tree2, output,
 
327
        specific_files=specific_files,
 
328
        extra_trees=extra_trees, old_label='old/',
 
329
        new_label='new/')
 
330
    return output.getvalue()
 
331
 
 
332
 
 
333
class TestDiffDates(tests.TestCaseWithTransport):
292
334
 
293
335
    def setUp(self):
294
336
        super(TestDiffDates, self).setUp()
329
371
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
330
372
 
331
373
    def test_diff_rev_tree_working_tree(self):
332
 
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
374
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
333
375
        # note that the date for old/file1 is from rev 2 rather than from
334
376
        # the basis revision (rev 4)
335
377
        self.assertEqualDiff(output, '''\
345
387
    def test_diff_rev_tree_rev_tree(self):
346
388
        tree1 = self.b.repository.revision_tree('rev-2')
347
389
        tree2 = self.b.repository.revision_tree('rev-3')
348
 
        output = self.get_diff(tree1, tree2)
 
390
        output = get_diff_as_string(tree1, tree2)
349
391
        self.assertEqualDiff(output, '''\
350
392
=== modified file 'file2'
351
393
--- old/file2\t2006-04-01 00:00:00 +0000
359
401
    def test_diff_add_files(self):
360
402
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
361
403
        tree2 = self.b.repository.revision_tree('rev-1')
362
 
        output = self.get_diff(tree1, tree2)
 
404
        output = get_diff_as_string(tree1, tree2)
363
405
        # the files have the epoch time stamp for the tree in which
364
406
        # they don't exist.
365
407
        self.assertEqualDiff(output, '''\
380
422
    def test_diff_remove_files(self):
381
423
        tree1 = self.b.repository.revision_tree('rev-3')
382
424
        tree2 = self.b.repository.revision_tree('rev-4')
383
 
        output = self.get_diff(tree1, tree2)
 
425
        output = get_diff_as_string(tree1, tree2)
384
426
        # the file has the epoch time stamp for the tree in which
385
427
        # it doesn't exist.
386
428
        self.assertEqualDiff(output, '''\
397
439
        self.wt.rename_one('file1', 'file1b')
398
440
        old_tree = self.b.repository.revision_tree('rev-1')
399
441
        new_tree = self.b.repository.revision_tree('rev-4')
400
 
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'],
 
442
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
401
443
                            working_tree=self.wt)
402
444
        self.assertContainsRe(out, 'file1\t')
403
445
 
409
451
        self.wt.rename_one('file1', 'dir1/file1')
410
452
        old_tree = self.b.repository.revision_tree('rev-1')
411
453
        new_tree = self.b.repository.revision_tree('rev-4')
412
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'],
 
454
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
413
455
                            working_tree=self.wt)
414
456
        self.assertContainsRe(out, 'file1\t')
415
 
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'],
 
457
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
416
458
                            working_tree=self.wt)
417
459
        self.assertNotContainsRe(out, 'file1\t')
418
460
 
419
461
 
420
 
 
421
 
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
462
class TestShowDiffTrees(tests.TestCaseWithTransport):
422
463
    """Direct tests for show_diff_trees"""
423
464
 
424
465
    def test_modified_file(self):
429
470
        tree.commit('one', rev_id='rev-1')
430
471
 
431
472
        self.build_tree_contents([('tree/file', 'new contents\n')])
432
 
        diff = self.get_diff(tree.basis_tree(), tree)
433
 
        self.assertContainsRe(diff, "=== modified file 'file'\n")
434
 
        self.assertContainsRe(diff, '--- old/file\t')
435
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
436
 
        self.assertContainsRe(diff, '-contents\n'
437
 
                                    '\\+new contents\n')
 
473
        d = get_diff_as_string(tree.basis_tree(), tree)
 
474
        self.assertContainsRe(d, "=== modified file 'file'\n")
 
475
        self.assertContainsRe(d, '--- old/file\t')
 
476
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
 
477
        self.assertContainsRe(d, '-contents\n'
 
478
                                 '\\+new contents\n')
438
479
 
439
480
    def test_modified_file_in_renamed_dir(self):
440
481
        """Test when a file is modified in a renamed directory."""
446
487
 
447
488
        tree.rename_one('dir', 'other')
448
489
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
449
 
        diff = self.get_diff(tree.basis_tree(), tree)
450
 
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
451
 
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
 
490
        d = get_diff_as_string(tree.basis_tree(), tree)
 
491
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
 
492
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
452
493
        # XXX: This is technically incorrect, because it used to be at another
453
494
        # location. What to do?
454
 
        self.assertContainsRe(diff, '--- old/dir/file\t')
455
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
456
 
        self.assertContainsRe(diff, '-contents\n'
457
 
                                    '\\+new contents\n')
 
495
        self.assertContainsRe(d, '--- old/dir/file\t')
 
496
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
 
497
        self.assertContainsRe(d, '-contents\n'
 
498
                                 '\\+new contents\n')
458
499
 
459
500
    def test_renamed_directory(self):
460
501
        """Test when only a directory is only renamed."""
465
506
        tree.commit('one', rev_id='rev-1')
466
507
 
467
508
        tree.rename_one('dir', 'newdir')
468
 
        diff = self.get_diff(tree.basis_tree(), tree)
 
509
        d = get_diff_as_string(tree.basis_tree(), tree)
469
510
        # Renaming a directory should be a single "you renamed this dir" even
470
511
        # when there are files inside.
471
 
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
 
512
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
472
513
 
473
514
    def test_renamed_file(self):
474
515
        """Test when a file is only renamed."""
478
519
        tree.commit('one', rev_id='rev-1')
479
520
 
480
521
        tree.rename_one('file', 'newname')
481
 
        diff = self.get_diff(tree.basis_tree(), tree)
482
 
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
522
        d = get_diff_as_string(tree.basis_tree(), tree)
 
523
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
483
524
        # We shouldn't have a --- or +++ line, because there is no content
484
525
        # change
485
 
        self.assertNotContainsRe(diff, '---')
 
526
        self.assertNotContainsRe(d, '---')
486
527
 
487
528
    def test_renamed_and_modified_file(self):
488
529
        """Test when a file is only renamed."""
493
534
 
494
535
        tree.rename_one('file', 'newname')
495
536
        self.build_tree_contents([('tree/newname', 'new contents\n')])
496
 
        diff = self.get_diff(tree.basis_tree(), tree)
497
 
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
498
 
        self.assertContainsRe(diff, '--- old/file\t')
499
 
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
500
 
        self.assertContainsRe(diff, '-contents\n'
501
 
                                    '\\+new contents\n')
 
537
        d = get_diff_as_string(tree.basis_tree(), tree)
 
538
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
539
        self.assertContainsRe(d, '--- old/file\t')
 
540
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
 
541
        self.assertContainsRe(d, '-contents\n'
 
542
                                 '\\+new contents\n')
502
543
 
503
544
 
504
545
    def test_internal_diff_exec_property(self):
523
564
        tree.rename_one('c', 'new-c')
524
565
        tree.rename_one('d', 'new-d')
525
566
 
526
 
        diff = self.get_diff(tree.basis_tree(), tree)
527
 
 
528
 
        self.assertContainsRe(diff, r"file 'a'.*\(properties changed:.*\+x to -x.*\)")
529
 
        self.assertContainsRe(diff, r"file 'b'.*\(properties changed:.*-x to \+x.*\)")
530
 
        self.assertContainsRe(diff, r"file 'c'.*\(properties changed:.*\+x to -x.*\)")
531
 
        self.assertContainsRe(diff, r"file 'd'.*\(properties changed:.*-x to \+x.*\)")
532
 
        self.assertNotContainsRe(diff, r"file 'e'")
533
 
        self.assertNotContainsRe(diff, r"file 'f'")
534
 
 
 
567
        d = get_diff_as_string(tree.basis_tree(), tree)
 
568
 
 
569
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
 
570
                                  ".*\+x to -x.*\)")
 
571
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
 
572
                                  ".*-x to \+x.*\)")
 
573
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
 
574
                                  ".*\+x to -x.*\)")
 
575
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
 
576
                                  ".*-x to \+x.*\)")
 
577
        self.assertNotContainsRe(d, r"file 'e'")
 
578
        self.assertNotContainsRe(d, r"file 'f'")
535
579
 
536
580
    def test_binary_unicode_filenames(self):
537
581
        """Test that contents of files are *not* encoded in UTF-8 when there
538
582
        is a binary file in the diff.
539
583
        """
540
584
        # See https://bugs.launchpad.net/bugs/110092.
541
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
585
        self.requireFeature(features.UnicodeFilenameFeature)
542
586
 
543
587
        # This bug isn't triggered with cStringIO.
544
588
        from StringIO import StringIO
552
596
        tree.add([alpha], ['file-id'])
553
597
        tree.add([omega], ['file-id-2'])
554
598
        diff_content = StringIO()
555
 
        show_diff_trees(tree.basis_tree(), tree, diff_content)
556
 
        diff = diff_content.getvalue()
557
 
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
558
 
        self.assertContainsRe(
559
 
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
560
 
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
561
 
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
562
 
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
 
599
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
 
600
        d = diff_content.getvalue()
 
601
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
 
602
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
 
603
                              % (alpha_utf8, alpha_utf8))
 
604
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
 
605
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
 
606
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
563
607
 
564
608
    def test_unicode_filename(self):
565
609
        """Test when the filename are unicode."""
566
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
610
        self.requireFeature(features.UnicodeFilenameFeature)
567
611
 
568
612
        alpha, omega = u'\u03b1', u'\u03c9'
569
613
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
584
628
        tree.add(['add_'+alpha], ['file-id'])
585
629
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
586
630
 
587
 
        diff = self.get_diff(tree.basis_tree(), tree)
588
 
        self.assertContainsRe(diff,
 
631
        d = get_diff_as_string(tree.basis_tree(), tree)
 
632
        self.assertContainsRe(d,
589
633
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
590
 
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
591
 
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
592
 
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
593
 
 
594
 
 
595
 
class DiffWasIs(DiffPath):
 
634
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
 
635
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
 
636
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
 
637
 
 
638
    def test_unicode_filename_path_encoding(self):
 
639
        """Test for bug #382699: unicode filenames on Windows should be shown
 
640
        in user encoding.
 
641
        """
 
642
        self.requireFeature(features.UnicodeFilenameFeature)
 
643
        # The word 'test' in Russian
 
644
        _russian_test = u'\u0422\u0435\u0441\u0442'
 
645
        directory = _russian_test + u'/'
 
646
        test_txt = _russian_test + u'.txt'
 
647
        u1234 = u'\u1234.txt'
 
648
 
 
649
        tree = self.make_branch_and_tree('.')
 
650
        self.build_tree_contents([
 
651
            (test_txt, 'foo\n'),
 
652
            (u1234, 'foo\n'),
 
653
            (directory, None),
 
654
            ])
 
655
        tree.add([test_txt, u1234, directory])
 
656
 
 
657
        sio = StringIO()
 
658
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
 
659
            path_encoding='cp1251')
 
660
 
 
661
        output = subst_dates(sio.getvalue())
 
662
        shouldbe = ('''\
 
663
=== added directory '%(directory)s'
 
664
=== added file '%(test_txt)s'
 
665
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
666
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
667
@@ -0,0 +1,1 @@
 
668
+foo
 
669
 
 
670
=== added file '?.txt'
 
671
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
672
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
 
673
@@ -0,0 +1,1 @@
 
674
+foo
 
675
 
 
676
''' % {'directory': _russian_test.encode('cp1251'),
 
677
       'test_txt': test_txt.encode('cp1251'),
 
678
      })
 
679
        self.assertEqualDiff(output, shouldbe)
 
680
 
 
681
 
 
682
class DiffWasIs(diff.DiffPath):
596
683
 
597
684
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
598
685
        self.to_file.write('was: ')
602
689
        pass
603
690
 
604
691
 
605
 
class TestDiffTree(TestCaseWithTransport):
 
692
class TestDiffTree(tests.TestCaseWithTransport):
606
693
 
607
694
    def setUp(self):
608
 
        TestCaseWithTransport.setUp(self)
 
695
        super(TestDiffTree, self).setUp()
609
696
        self.old_tree = self.make_branch_and_tree('old-tree')
610
697
        self.old_tree.lock_write()
611
698
        self.addCleanup(self.old_tree.unlock)
612
699
        self.new_tree = self.make_branch_and_tree('new-tree')
613
700
        self.new_tree.lock_write()
614
701
        self.addCleanup(self.new_tree.unlock)
615
 
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
 
702
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
616
703
 
617
704
    def test_diff_text(self):
618
705
        self.build_tree_contents([('old-tree/olddir/',),
623
710
                                  ('new-tree/newdir/newfile', 'new\n')])
624
711
        self.new_tree.add('newdir')
625
712
        self.new_tree.add('newdir/newfile', 'file-id')
626
 
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
 
713
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
627
714
        differ.diff_text('file-id', None, 'old label', 'new label')
628
715
        self.assertEqual(
629
716
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
658
745
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
659
746
 
660
747
    def test_diff_symlink(self):
661
 
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
748
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
662
749
        differ.diff_symlink('old target', None)
663
750
        self.assertEqual("=== target was 'old target'\n",
664
751
                         differ.to_file.getvalue())
665
752
 
666
 
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
753
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
667
754
        differ.diff_symlink(None, 'new target')
668
755
        self.assertEqual("=== target is 'new target'\n",
669
756
                         differ.to_file.getvalue())
670
757
 
671
 
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
758
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
672
759
        differ.diff_symlink('old target', 'new target')
673
760
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
674
761
                         differ.to_file.getvalue())
689
776
             ' \@\@\n-old\n\+new\n\n')
690
777
 
691
778
    def test_diff_kind_change(self):
692
 
        self.requireFeature(tests.SymlinkFeature)
 
779
        self.requireFeature(features.SymlinkFeature)
693
780
        self.build_tree_contents([('old-tree/olddir/',),
694
781
                                  ('old-tree/olddir/oldfile', 'old\n')])
695
782
        self.old_tree.add('olddir')
724
811
 
725
812
    def test_register_diff(self):
726
813
        self.create_old_new()
727
 
        old_diff_factories = DiffTree.diff_factories
728
 
        DiffTree.diff_factories=old_diff_factories[:]
729
 
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
814
        old_diff_factories = diff.DiffTree.diff_factories
 
815
        diff.DiffTree.diff_factories=old_diff_factories[:]
 
816
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
730
817
        try:
731
 
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
 
818
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
732
819
        finally:
733
 
            DiffTree.diff_factories = old_diff_factories
 
820
            diff.DiffTree.diff_factories = old_diff_factories
734
821
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
735
822
        self.assertNotContainsRe(
736
823
            differ.to_file.getvalue(),
741
828
 
742
829
    def test_extra_factories(self):
743
830
        self.create_old_new()
744
 
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
745
 
                            extra_factories=[DiffWasIs.from_diff_tree])
 
831
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
 
832
                               extra_factories=[DiffWasIs.from_diff_tree])
746
833
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
747
834
        self.assertNotContainsRe(
748
835
            differ.to_file.getvalue(),
761
848
            '.*a-file(.|\n)*b-file')
762
849
 
763
850
 
764
 
class TestPatienceDiffLib(TestCase):
 
851
class TestPatienceDiffLib(tests.TestCase):
765
852
 
766
853
    def setUp(self):
767
854
        super(TestPatienceDiffLib, self).setUp()
768
 
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
769
 
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
 
855
        self._unique_lcs = _patiencediff_py.unique_lcs_py
 
856
        self._recurse_matches = _patiencediff_py.recurse_matches_py
770
857
        self._PatienceSequenceMatcher = \
771
 
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
 
858
            _patiencediff_py.PatienceSequenceMatcher_py
772
859
 
773
860
    def test_diff_unicode_string(self):
774
861
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
775
862
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
776
863
        sm = self._PatienceSequenceMatcher(None, a, b)
777
864
        mb = sm.get_matching_blocks()
778
 
        self.assertEquals(35, len(mb))
 
865
        self.assertEqual(35, len(mb))
779
866
 
780
867
    def test_unique_lcs(self):
781
868
        unique_lcs = self._unique_lcs
782
 
        self.assertEquals(unique_lcs('', ''), [])
783
 
        self.assertEquals(unique_lcs('', 'a'), [])
784
 
        self.assertEquals(unique_lcs('a', ''), [])
785
 
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
786
 
        self.assertEquals(unique_lcs('a', 'b'), [])
787
 
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
788
 
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
789
 
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
790
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
869
        self.assertEqual(unique_lcs('', ''), [])
 
870
        self.assertEqual(unique_lcs('', 'a'), [])
 
871
        self.assertEqual(unique_lcs('a', ''), [])
 
872
        self.assertEqual(unique_lcs('a', 'a'), [(0,0)])
 
873
        self.assertEqual(unique_lcs('a', 'b'), [])
 
874
        self.assertEqual(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
 
875
        self.assertEqual(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
 
876
        self.assertEqual(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
 
877
        self.assertEqual(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
791
878
                                                         (3,3), (4,4)])
792
 
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
 
879
        self.assertEqual(unique_lcs('acbac', 'abc'), [(2,1)])
793
880
 
794
881
    def test_recurse_matches(self):
795
882
        def test_one(a, b, matches):
796
883
            test_matches = []
797
884
            self._recurse_matches(
798
885
                a, b, 0, 0, len(a), len(b), test_matches, 10)
799
 
            self.assertEquals(test_matches, matches)
 
886
            self.assertEqual(test_matches, matches)
800
887
 
801
888
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
802
889
                 [(0, 0), (2, 2), (4, 4)])
907
994
    def test_opcodes(self):
908
995
        def chk_ops(a, b, expected_codes):
909
996
            s = self._PatienceSequenceMatcher(None, a, b)
910
 
            self.assertEquals(expected_codes, s.get_opcodes())
 
997
            self.assertEqual(expected_codes, s.get_opcodes())
911
998
 
912
999
        chk_ops('', '', [])
913
1000
        chk_ops([], [], [])
983
1070
    def test_grouped_opcodes(self):
984
1071
        def chk_ops(a, b, expected_codes, n=3):
985
1072
            s = self._PatienceSequenceMatcher(None, a, b)
986
 
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
 
1073
            self.assertEqual(expected_codes, list(s.get_grouped_opcodes(n)))
987
1074
 
988
1075
        chk_ops('', '', [])
989
1076
        chk_ops([], [], [])
1081
1168
                 'how are you today?\n']
1082
1169
        txt_b = ['hello there\n',
1083
1170
                 'how are you today?\n']
1084
 
        unified_diff = bzrlib.patiencediff.unified_diff
 
1171
        unified_diff = patiencediff.unified_diff
1085
1172
        psm = self._PatienceSequenceMatcher
1086
 
        self.assertEquals(['--- \n',
 
1173
        self.assertEqual(['--- \n',
1087
1174
                           '+++ \n',
1088
1175
                           '@@ -1,3 +1,2 @@\n',
1089
1176
                           ' hello there\n',
1095
1182
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1096
1183
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1097
1184
        # This is the result with LongestCommonSubstring matching
1098
 
        self.assertEquals(['--- \n',
 
1185
        self.assertEqual(['--- \n',
1099
1186
                           '+++ \n',
1100
1187
                           '@@ -1,6 +1,11 @@\n',
1101
1188
                           ' a\n',
1111
1198
                           ' f\n']
1112
1199
                          , list(unified_diff(txt_a, txt_b)))
1113
1200
        # And the patience diff
1114
 
        self.assertEquals(['--- \n',
 
1201
        self.assertEqual(['--- \n',
1115
1202
                           '+++ \n',
1116
1203
                           '@@ -4,6 +4,11 @@\n',
1117
1204
                           ' d\n',
1135
1222
                 'how are you today?\n']
1136
1223
        txt_b = ['hello there\n',
1137
1224
                 'how are you today?\n']
1138
 
        unified_diff = bzrlib.patiencediff.unified_diff
 
1225
        unified_diff = patiencediff.unified_diff
1139
1226
        psm = self._PatienceSequenceMatcher
1140
 
        self.assertEquals(['--- a\t2008-08-08\n',
 
1227
        self.assertEqual(['--- a\t2008-08-08\n',
1141
1228
                           '+++ b\t2008-09-09\n',
1142
1229
                           '@@ -1,3 +1,2 @@\n',
1143
1230
                           ' hello there\n',
1153
1240
 
1154
1241
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1155
1242
 
1156
 
    _test_needs_features = [CompiledPatienceDiffFeature]
 
1243
    _test_needs_features = [features.compiled_patiencediff_feature]
1157
1244
 
1158
1245
    def setUp(self):
1159
1246
        super(TestPatienceDiffLib_c, self).setUp()
1160
 
        import bzrlib._patiencediff_c
1161
 
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
1162
 
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
 
1247
        from bzrlib import _patiencediff_c
 
1248
        self._unique_lcs = _patiencediff_c.unique_lcs_c
 
1249
        self._recurse_matches = _patiencediff_c.recurse_matches_c
1163
1250
        self._PatienceSequenceMatcher = \
1164
 
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1251
            _patiencediff_c.PatienceSequenceMatcher_c
1165
1252
 
1166
1253
    def test_unhashable(self):
1167
1254
        """We should get a proper exception here."""
1177
1264
                                         None, ['valid'], ['valid', []])
1178
1265
 
1179
1266
 
1180
 
class TestPatienceDiffLibFiles(TestCaseInTempDir):
 
1267
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
1181
1268
 
1182
1269
    def setUp(self):
1183
1270
        super(TestPatienceDiffLibFiles, self).setUp()
1184
1271
        self._PatienceSequenceMatcher = \
1185
 
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
 
1272
            _patiencediff_py.PatienceSequenceMatcher_py
1186
1273
 
1187
1274
    def test_patience_unified_diff_files(self):
1188
1275
        txt_a = ['hello there\n',
1190
1277
                 'how are you today?\n']
1191
1278
        txt_b = ['hello there\n',
1192
1279
                 'how are you today?\n']
1193
 
        open('a1', 'wb').writelines(txt_a)
1194
 
        open('b1', 'wb').writelines(txt_b)
 
1280
        with open('a1', 'wb') as f: f.writelines(txt_a)
 
1281
        with open('b1', 'wb') as f: f.writelines(txt_b)
1195
1282
 
1196
 
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
 
1283
        unified_diff_files = patiencediff.unified_diff_files
1197
1284
        psm = self._PatienceSequenceMatcher
1198
 
        self.assertEquals(['--- a1\n',
 
1285
        self.assertEqual(['--- a1\n',
1199
1286
                           '+++ b1\n',
1200
1287
                           '@@ -1,3 +1,2 @@\n',
1201
1288
                           ' hello there\n',
1207
1294
 
1208
1295
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1209
1296
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1210
 
        open('a2', 'wb').writelines(txt_a)
1211
 
        open('b2', 'wb').writelines(txt_b)
 
1297
        with open('a2', 'wb') as f: f.writelines(txt_a)
 
1298
        with open('b2', 'wb') as f: f.writelines(txt_b)
1212
1299
 
1213
1300
        # This is the result with LongestCommonSubstring matching
1214
 
        self.assertEquals(['--- a2\n',
 
1301
        self.assertEqual(['--- a2\n',
1215
1302
                           '+++ b2\n',
1216
1303
                           '@@ -1,6 +1,11 @@\n',
1217
1304
                           ' a\n',
1228
1315
                          , list(unified_diff_files('a2', 'b2')))
1229
1316
 
1230
1317
        # And the patience diff
1231
 
        self.assertEquals(['--- a2\n',
1232
 
                           '+++ b2\n',
1233
 
                           '@@ -4,6 +4,11 @@\n',
1234
 
                           ' d\n',
1235
 
                           ' e\n',
1236
 
                           ' f\n',
1237
 
                           '+x\n',
1238
 
                           '+y\n',
1239
 
                           '+d\n',
1240
 
                           '+e\n',
1241
 
                           '+f\n',
1242
 
                           ' g\n',
1243
 
                           ' h\n',
1244
 
                           ' i\n',
1245
 
                          ]
1246
 
                          , list(unified_diff_files('a2', 'b2',
1247
 
                                 sequencematcher=psm)))
 
1318
        self.assertEqual(['--- a2\n',
 
1319
                          '+++ b2\n',
 
1320
                          '@@ -4,6 +4,11 @@\n',
 
1321
                          ' d\n',
 
1322
                          ' e\n',
 
1323
                          ' f\n',
 
1324
                          '+x\n',
 
1325
                          '+y\n',
 
1326
                          '+d\n',
 
1327
                          '+e\n',
 
1328
                          '+f\n',
 
1329
                          ' g\n',
 
1330
                          ' h\n',
 
1331
                          ' i\n'],
 
1332
                         list(unified_diff_files('a2', 'b2',
 
1333
                                                 sequencematcher=psm)))
1248
1334
 
1249
1335
 
1250
1336
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1251
1337
 
1252
 
    _test_needs_features = [CompiledPatienceDiffFeature]
 
1338
    _test_needs_features = [features.compiled_patiencediff_feature]
1253
1339
 
1254
1340
    def setUp(self):
1255
1341
        super(TestPatienceDiffLibFiles_c, self).setUp()
1256
 
        import bzrlib._patiencediff_c
 
1342
        from bzrlib import _patiencediff_c
1257
1343
        self._PatienceSequenceMatcher = \
1258
 
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1259
 
 
1260
 
 
1261
 
class TestUsingCompiledIfAvailable(TestCase):
 
1344
            _patiencediff_c.PatienceSequenceMatcher_c
 
1345
 
 
1346
 
 
1347
class TestUsingCompiledIfAvailable(tests.TestCase):
1262
1348
 
1263
1349
    def test_PatienceSequenceMatcher(self):
1264
 
        if CompiledPatienceDiffFeature.available():
 
1350
        if features.compiled_patiencediff_feature.available():
1265
1351
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1266
1352
            self.assertIs(PatienceSequenceMatcher_c,
1267
 
                          bzrlib.patiencediff.PatienceSequenceMatcher)
 
1353
                          patiencediff.PatienceSequenceMatcher)
1268
1354
        else:
1269
1355
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1270
1356
            self.assertIs(PatienceSequenceMatcher_py,
1271
 
                          bzrlib.patiencediff.PatienceSequenceMatcher)
 
1357
                          patiencediff.PatienceSequenceMatcher)
1272
1358
 
1273
1359
    def test_unique_lcs(self):
1274
 
        if CompiledPatienceDiffFeature.available():
 
1360
        if features.compiled_patiencediff_feature.available():
1275
1361
            from bzrlib._patiencediff_c import unique_lcs_c
1276
1362
            self.assertIs(unique_lcs_c,
1277
 
                          bzrlib.patiencediff.unique_lcs)
 
1363
                          patiencediff.unique_lcs)
1278
1364
        else:
1279
1365
            from bzrlib._patiencediff_py import unique_lcs_py
1280
1366
            self.assertIs(unique_lcs_py,
1281
 
                          bzrlib.patiencediff.unique_lcs)
 
1367
                          patiencediff.unique_lcs)
1282
1368
 
1283
1369
    def test_recurse_matches(self):
1284
 
        if CompiledPatienceDiffFeature.available():
 
1370
        if features.compiled_patiencediff_feature.available():
1285
1371
            from bzrlib._patiencediff_c import recurse_matches_c
1286
1372
            self.assertIs(recurse_matches_c,
1287
 
                          bzrlib.patiencediff.recurse_matches)
 
1373
                          patiencediff.recurse_matches)
1288
1374
        else:
1289
1375
            from bzrlib._patiencediff_py import recurse_matches_py
1290
1376
            self.assertIs(recurse_matches_py,
1291
 
                          bzrlib.patiencediff.recurse_matches)
1292
 
 
1293
 
 
1294
 
class TestDiffFromTool(TestCaseWithTransport):
 
1377
                          patiencediff.recurse_matches)
 
1378
 
 
1379
 
 
1380
class TestDiffFromTool(tests.TestCaseWithTransport):
1295
1381
 
1296
1382
    def test_from_string(self):
1297
 
        diff_obj = DiffFromTool.from_string('diff', None, None, None)
 
1383
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
1298
1384
        self.addCleanup(diff_obj.finish)
1299
 
        self.assertEqual(['diff', '%(old_path)s', '%(new_path)s'],
 
1385
        self.assertEqual(['diff', '@old_path', '@new_path'],
1300
1386
            diff_obj.command_template)
1301
1387
 
1302
1388
    def test_from_string_u5(self):
1303
 
        diff_obj = DiffFromTool.from_string('diff -u\\ 5', None, None, None)
 
1389
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
 
1390
                                                 None, None, None)
1304
1391
        self.addCleanup(diff_obj.finish)
1305
 
        self.assertEqual(['diff', '-u 5', '%(old_path)s', '%(new_path)s'],
 
1392
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1306
1393
                         diff_obj.command_template)
1307
1394
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1308
1395
                         diff_obj._get_command('old-path', 'new-path'))
1309
1396
 
 
1397
    def test_from_string_path_with_backslashes(self):
 
1398
        self.requireFeature(features.backslashdir_feature)
 
1399
        tool = 'C:\\Tools\\Diff.exe'
 
1400
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
 
1401
        self.addCleanup(diff_obj.finish)
 
1402
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
 
1403
                         diff_obj.command_template)
 
1404
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
 
1405
                         diff_obj._get_command('old-path', 'new-path'))
 
1406
 
1310
1407
    def test_execute(self):
1311
1408
        output = StringIO()
1312
 
        diff_obj = DiffFromTool(['python', '-c',
1313
 
                                 'print "%(old_path)s %(new_path)s"'],
1314
 
                                None, None, output)
 
1409
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1410
                                      'print "@old_path @new_path"'],
 
1411
                                     None, None, output)
1315
1412
        self.addCleanup(diff_obj.finish)
1316
1413
        diff_obj._execute('old', 'new')
1317
1414
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1318
1415
 
1319
 
    def test_excute_missing(self):
1320
 
        diff_obj = DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1321
 
                                None, None, None)
 
1416
    def test_execute_missing(self):
 
1417
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
 
1418
                                     None, None, None)
1322
1419
        self.addCleanup(diff_obj.finish)
1323
 
        e = self.assertRaises(ExecutableMissing, diff_obj._execute, 'old',
1324
 
                              'new')
 
1420
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
 
1421
                              'old', 'new')
1325
1422
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1326
1423
                         ' on this machine', str(e))
1327
1424
 
1328
1425
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1329
 
        self.requireFeature(AttribFeature)
 
1426
        self.requireFeature(features.AttribFeature)
1330
1427
        output = StringIO()
1331
1428
        tree = self.make_branch_and_tree('tree')
1332
1429
        self.build_tree_contents([('tree/file', 'content')])
1334
1431
        tree.commit('old tree')
1335
1432
        tree.lock_read()
1336
1433
        self.addCleanup(tree.unlock)
1337
 
        diff_obj = DiffFromTool(['python', '-c',
1338
 
                                 'print "%(old_path)s %(new_path)s"'],
1339
 
                                tree, tree, output)
 
1434
        basis_tree = tree.basis_tree()
 
1435
        basis_tree.lock_read()
 
1436
        self.addCleanup(basis_tree.unlock)
 
1437
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1438
                                      'print "@old_path @new_path"'],
 
1439
                                     basis_tree, tree, output)
1340
1440
        diff_obj._prepare_files('file-id', 'file', 'file')
1341
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file', r'old\\file')
1342
 
        self.assertReadableByAttrib(diff_obj._root, 'new\\file', r'new\\file')
 
1441
        # The old content should be readonly
 
1442
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
 
1443
                                    r'R.*old\\file$')
 
1444
        # The new content should use the tree object, not a 'new' file anymore
 
1445
        self.assertEndsWith(tree.basedir, 'work/tree')
 
1446
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1343
1447
 
1344
1448
    def assertReadableByAttrib(self, cwd, relpath, regex):
1345
1449
        proc = subprocess.Popen(['attrib', relpath],
1346
1450
                                stdout=subprocess.PIPE,
1347
1451
                                cwd=cwd)
1348
 
        proc.wait()
1349
 
        result = proc.stdout.read()
1350
 
        self.assertContainsRe(result, regex)
 
1452
        (result, err) = proc.communicate()
 
1453
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1351
1454
 
1352
1455
    def test_prepare_files(self):
1353
1456
        output = StringIO()
1356
1459
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1357
1460
        tree.add('oldname', 'file-id')
1358
1461
        tree.add('oldname2', 'file2-id')
1359
 
        tree.commit('old tree', timestamp=0)
 
1462
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
 
1463
        tree.commit('old tree', timestamp=315532800)
1360
1464
        tree.rename_one('oldname', 'newname')
1361
1465
        tree.rename_one('oldname2', 'newname2')
1362
1466
        self.build_tree_contents([('tree/newname', 'newcontent')])
1366
1470
        self.addCleanup(old_tree.unlock)
1367
1471
        tree.lock_read()
1368
1472
        self.addCleanup(tree.unlock)
1369
 
        diff_obj = DiffFromTool(['python', '-c',
1370
 
                                 'print "%(old_path)s %(new_path)s"'],
1371
 
                                old_tree, tree, output)
 
1473
        diff_obj = diff.DiffFromTool(['python', '-c',
 
1474
                                      'print "@old_path @new_path"'],
 
1475
                                     old_tree, tree, output)
1372
1476
        self.addCleanup(diff_obj.finish)
1373
1477
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1374
1478
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1375
1479
                                                     'newname')
1376
1480
        self.assertContainsRe(old_path, 'old/oldname$')
1377
 
        self.assertEqual(0, os.stat(old_path).st_mtime)
1378
 
        self.assertContainsRe(new_path, 'new/newname$')
 
1481
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
 
1482
        self.assertContainsRe(new_path, 'tree/newname$')
1379
1483
        self.assertFileEqual('oldcontent', old_path)
1380
1484
        self.assertFileEqual('newcontent', new_path)
1381
1485
        if osutils.host_os_dereferences_symlinks():
1382
1486
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1383
1487
        # make sure we can create files with the same parent directories
1384
1488
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
 
1489
 
 
1490
 
 
1491
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
 
1492
 
 
1493
    def test_encodable_filename(self):
 
1494
        # Just checks file path for external diff tool.
 
1495
        # We cannot change CPython's internal encoding used by os.exec*.
 
1496
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1497
                                    None, None, None)
 
1498
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1499
            encoding = scenario['encoding']
 
1500
            dirname = scenario['info']['directory']
 
1501
            filename = scenario['info']['filename']
 
1502
 
 
1503
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1504
            relpath = dirname + u'/' + filename
 
1505
            fullpath = diffobj._safe_filename('safe', relpath)
 
1506
            self.assertEqual(fullpath,
 
1507
                             fullpath.encode(encoding).decode(encoding))
 
1508
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
 
1509
 
 
1510
    def test_unencodable_filename(self):
 
1511
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
 
1512
                                    None, None, None)
 
1513
        for _, scenario in EncodingAdapter.encoding_scenarios:
 
1514
            encoding = scenario['encoding']
 
1515
            dirname = scenario['info']['directory']
 
1516
            filename = scenario['info']['filename']
 
1517
 
 
1518
            if encoding == 'iso-8859-1':
 
1519
                encoding = 'iso-8859-2'
 
1520
            else:
 
1521
                encoding = 'iso-8859-1'
 
1522
 
 
1523
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
 
1524
            relpath = dirname + u'/' + filename
 
1525
            fullpath = diffobj._safe_filename('safe', relpath)
 
1526
            self.assertEqual(fullpath,
 
1527
                             fullpath.encode(encoding).decode(encoding))
 
1528
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
 
1529
 
 
1530
 
 
1531
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
 
1532
 
 
1533
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
 
1534
        """Call get_trees_and_branches_to_diff_locked."""
 
1535
        return diff.get_trees_and_branches_to_diff_locked(
 
1536
            path_list, revision_specs, old_url, new_url, self.addCleanup)
 
1537
 
 
1538
    def test_basic(self):
 
1539
        tree = self.make_branch_and_tree('tree')
 
1540
        (old_tree, new_tree,
 
1541
         old_branch, new_branch,
 
1542
         specific_files, extra_trees) = self.call_gtabtd(
 
1543
             ['tree'], None, None, None)
 
1544
 
 
1545
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1546
        self.assertEqual(_mod_revision.NULL_REVISION,
 
1547
                         old_tree.get_revision_id())
 
1548
        self.assertEqual(tree.basedir, new_tree.basedir)
 
1549
        self.assertEqual(tree.branch.base, old_branch.base)
 
1550
        self.assertEqual(tree.branch.base, new_branch.base)
 
1551
        self.assertIs(None, specific_files)
 
1552
        self.assertIs(None, extra_trees)
 
1553
 
 
1554
    def test_with_rev_specs(self):
 
1555
        tree = self.make_branch_and_tree('tree')
 
1556
        self.build_tree_contents([('tree/file', 'oldcontent')])
 
1557
        tree.add('file', 'file-id')
 
1558
        tree.commit('old tree', timestamp=0, rev_id="old-id")
 
1559
        self.build_tree_contents([('tree/file', 'newcontent')])
 
1560
        tree.commit('new tree', timestamp=0, rev_id="new-id")
 
1561
 
 
1562
        revisions = [revisionspec.RevisionSpec.from_string('1'),
 
1563
                     revisionspec.RevisionSpec.from_string('2')]
 
1564
        (old_tree, new_tree,
 
1565
         old_branch, new_branch,
 
1566
         specific_files, extra_trees) = self.call_gtabtd(
 
1567
            ['tree'], revisions, None, None)
 
1568
 
 
1569
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
 
1570
        self.assertEqual("old-id", old_tree.get_revision_id())
 
1571
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
 
1572
        self.assertEqual("new-id", new_tree.get_revision_id())
 
1573
        self.assertEqual(tree.branch.base, old_branch.base)
 
1574
        self.assertEqual(tree.branch.base, new_branch.base)
 
1575
        self.assertIs(None, specific_files)
 
1576
        self.assertEqual(tree.basedir, extra_trees[0].basedir)