← 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: Vincent Ladeuil
  • Date: 2007-12-21 12:20:33 UTC
  • mto: (3146.3.1 179368) (3156.2.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 3158.
  • Revision ID: v.ladeuil+lp@free.fr-20071221122033-42bc21re0zj4kqbg
Merge back test_http_implementations.pc into test_http.py.

* bzrlib/tests/test_http.py: 
Merge test_http_implementations.py now that we have rewritten
load_tests. That should reduce the noise in the final proposed
patch.

* bzrlib/tests/http_server.py:
(TestingHTTPRequestHandler.log_message): Ghaaa, don't over spell-check.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2012, 2014, 2016 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
18
from cStringIO import StringIO
 
19
import errno
19
20
import subprocess
20
 
import tempfile
 
21
from tempfile import TemporaryFile
21
22
 
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,
 
23
from bzrlib.diff import (
 
24
    internal_diff,
 
25
    external_diff,
 
26
    DiffPath,
 
27
    show_diff_trees,
 
28
    DiffSymlink,
 
29
    DiffTree,
 
30
    DiffText,
33
31
    )
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
43
 
 
 
32
from bzrlib.errors import BinaryFile, NoDiff
 
33
import bzrlib.osutils as osutils
 
34
import bzrlib.patiencediff
 
35
import bzrlib._patiencediff_py
 
36
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
37
                          TestCaseInTempDir, TestSkipped)
 
38
 
 
39
 
 
40
class _CompiledPatienceDiffFeature(Feature):
 
41
 
 
42
    def _probe(self):
 
43
        try:
 
44
            import bzrlib._patiencediff_c
 
45
        except ImportError:
 
46
            return False
 
47
        return True
 
48
 
 
49
    def feature_name(self):
 
50
        return 'bzrlib._patiencediff_c'
 
51
 
 
52
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
 
53
 
 
54
 
 
55
class _UnicodeFilename(Feature):
 
56
    """Does the filesystem support Unicode filenames?"""
 
57
 
 
58
    def _probe(self):
 
59
        try:
 
60
            os.stat(u'\u03b1')
 
61
        except UnicodeEncodeError:
 
62
            return False
 
63
        except (IOError, OSError):
 
64
            # The filesystem allows the Unicode filename but the file doesn't
 
65
            # exist.
 
66
            return True
 
67
        else:
 
68
            # The filesystem allows the Unicode filename and the file exists,
 
69
            # for some reason.
 
70
            return True
 
71
 
 
72
UnicodeFilename = _UnicodeFilename()
 
73
 
 
74
 
 
75
class TestUnicodeFilename(TestCase):
 
76
 
 
77
    def test_probe_passes(self):
 
78
        """UnicodeFilename._probe passes."""
 
79
        # We can't test much more than that because the behaviour depends
 
80
        # on the platform.
 
81
        UnicodeFilename._probe()
 
82
        
44
83
 
45
84
def udiff_lines(old, new, allow_binary=False):
46
85
    output = StringIO()
47
 
    diff.internal_diff('old', old, 'new', new, output, allow_binary)
 
86
    internal_diff('old', old, 'new', new, output, allow_binary)
48
87
    output.seek(0, 0)
49
88
    return output.readlines()
50
89
 
54
93
        # StringIO has no fileno, so it tests a different codepath
55
94
        output = StringIO()
56
95
    else:
57
 
        output = tempfile.TemporaryFile()
 
96
        output = TemporaryFile()
58
97
    try:
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')
 
98
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
99
    except NoDiff:
 
100
        raise TestSkipped('external "diff" not present to test')
62
101
    output.seek(0, 0)
63
102
    lines = output.readlines()
64
103
    output.close()
65
104
    return lines
66
105
 
67
106
 
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):
 
107
class TestDiff(TestCase):
92
108
 
93
109
    def test_add_nl(self):
94
110
        """diff generates a valid diff for patches that add a newline"""
95
111
        lines = udiff_lines(['boo'], ['boo\n'])
96
112
        self.check_patch(lines)
97
 
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
 
113
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
98
114
            ## "expected no-nl, got %r" % lines[4]
99
115
 
100
116
    def test_add_nl_2(self):
103
119
        """
104
120
        lines = udiff_lines(['boo'], ['goo\n'])
105
121
        self.check_patch(lines)
106
 
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
 
122
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
107
123
            ## "expected no-nl, got %r" % lines[4]
108
124
 
109
125
    def test_remove_nl(self):
112
128
        """
113
129
        lines = udiff_lines(['boo\n'], ['boo'])
114
130
        self.check_patch(lines)
115
 
        self.assertEqual(lines[5], '\\ No newline at end of file\n')
 
131
        self.assertEquals(lines[5], '\\ No newline at end of file\n')
116
132
            ## "expected no-nl, got %r" % lines[5]
117
133
 
118
134
    def check_patch(self, lines):
119
 
        self.assertTrue(len(lines) > 1)
 
135
        self.assert_(len(lines) > 1)
120
136
            ## "Not enough lines for a file header for patch:\n%s" % "".join(lines)
121
 
        self.assertTrue(lines[0].startswith ('---'))
 
137
        self.assert_(lines[0].startswith ('---'))
122
138
            ## 'No orig line for patch:\n%s' % "".join(lines)
123
 
        self.assertTrue(lines[1].startswith ('+++'))
 
139
        self.assert_(lines[1].startswith ('+++'))
124
140
            ## 'No mod line for patch:\n%s' % "".join(lines)
125
 
        self.assertTrue(len(lines) > 2)
 
141
        self.assert_(len(lines) > 2)
126
142
            ## "No hunks for patch:\n%s" % "".join(lines)
127
 
        self.assertTrue(lines[2].startswith('@@'))
 
143
        self.assert_(lines[2].startswith('@@'))
128
144
            ## "No hunk header for patch:\n%s" % "".join(lines)
129
 
        self.assertTrue('@@' in lines[2][2:])
 
145
        self.assert_('@@' in lines[2][2:])
130
146
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
131
147
 
132
148
    def test_binary_lines(self):
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)
 
149
        self.assertRaises(BinaryFile, udiff_lines, [1023 * 'a' + '\x00'], [])
 
150
        self.assertRaises(BinaryFile, udiff_lines, [], [1023 * 'a' + '\x00'])
 
151
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
 
152
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
139
153
 
140
154
    def test_external_diff(self):
141
155
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
151
165
        self.check_patch(lines)
152
166
 
153
167
    def test_external_diff_binary_lang_c(self):
 
168
        old_env = {}
154
169
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
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'])
 
170
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
171
        try:
 
172
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
173
            # Older versions of diffutils say "Binary files", newer
 
174
            # versions just say "Files".
 
175
            self.assertContainsRe(lines[0],
 
176
                                  '(Binary f|F)iles old and new differ\n')
 
177
            self.assertEquals(lines[1:], ['\n'])
 
178
        finally:
 
179
            for lang, old_val in old_env.iteritems():
 
180
                osutils.set_or_unset_env(lang, old_val)
161
181
 
162
182
    def test_no_external_diff(self):
163
183
        """Check that NoDiff is raised when diff is not available"""
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'])
170
 
 
 
184
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
185
        orig_path = os.environ['PATH']
 
186
        try:
 
187
            os.environ['PATH'] = ''
 
188
            self.assertRaises(NoDiff, external_diff,
 
189
                              'old', ['boo\n'], 'new', ['goo\n'],
 
190
                              StringIO(), diff_opts=['-u'])
 
191
        finally:
 
192
            os.environ['PATH'] = orig_path
 
193
        
171
194
    def test_internal_diff_default(self):
172
195
        # Default internal diff encoding is utf8
173
196
        output = StringIO()
174
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
175
 
                           u'new_\xe5', ['new_text\n'], output)
 
197
        internal_diff(u'old_\xb5', ['old_text\n'],
 
198
                    u'new_\xe5', ['new_text\n'], output)
176
199
        lines = output.getvalue().splitlines(True)
177
200
        self.check_patch(lines)
178
 
        self.assertEqual(['--- old_\xc2\xb5\n',
 
201
        self.assertEquals(['--- old_\xc2\xb5\n',
179
202
                           '+++ new_\xc3\xa5\n',
180
203
                           '@@ -1,1 +1,1 @@\n',
181
204
                           '-old_text\n',
186
209
 
187
210
    def test_internal_diff_utf8(self):
188
211
        output = StringIO()
189
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
190
 
                           u'new_\xe5', ['new_text\n'], output,
191
 
                           path_encoding='utf8')
 
212
        internal_diff(u'old_\xb5', ['old_text\n'],
 
213
                    u'new_\xe5', ['new_text\n'], output,
 
214
                    path_encoding='utf8')
192
215
        lines = output.getvalue().splitlines(True)
193
216
        self.check_patch(lines)
194
 
        self.assertEqual(['--- old_\xc2\xb5\n',
 
217
        self.assertEquals(['--- old_\xc2\xb5\n',
195
218
                           '+++ new_\xc3\xa5\n',
196
219
                           '@@ -1,1 +1,1 @@\n',
197
220
                           '-old_text\n',
202
225
 
203
226
    def test_internal_diff_iso_8859_1(self):
204
227
        output = StringIO()
205
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
206
 
                           u'new_\xe5', ['new_text\n'], output,
207
 
                           path_encoding='iso-8859-1')
 
228
        internal_diff(u'old_\xb5', ['old_text\n'],
 
229
                    u'new_\xe5', ['new_text\n'], output,
 
230
                    path_encoding='iso-8859-1')
208
231
        lines = output.getvalue().splitlines(True)
209
232
        self.check_patch(lines)
210
 
        self.assertEqual(['--- old_\xb5\n',
 
233
        self.assertEquals(['--- old_\xb5\n',
211
234
                           '+++ new_\xe5\n',
212
235
                           '@@ -1,1 +1,1 @@\n',
213
236
                           '-old_text\n',
218
241
 
219
242
    def test_internal_diff_no_content(self):
220
243
        output = StringIO()
221
 
        diff.internal_diff(u'old', [], u'new', [], output)
 
244
        internal_diff(u'old', [], u'new', [], output)
222
245
        self.assertEqual('', output.getvalue())
223
246
 
224
247
    def test_internal_diff_no_changes(self):
225
248
        output = StringIO()
226
 
        diff.internal_diff(u'old', ['text\n', 'contents\n'],
227
 
                           u'new', ['text\n', 'contents\n'],
228
 
                           output)
 
249
        internal_diff(u'old', ['text\n', 'contents\n'],
 
250
                      u'new', ['text\n', 'contents\n'],
 
251
                      output)
229
252
        self.assertEqual('', output.getvalue())
230
253
 
231
254
    def test_internal_diff_returns_bytes(self):
232
255
        import StringIO
233
256
        output = StringIO.StringIO()
234
 
        diff.internal_diff(u'old_\xb5', ['old_text\n'],
235
 
                            u'new_\xe5', ['new_text\n'], output)
236
 
        self.assertIsInstance(output.getvalue(), str,
 
257
        internal_diff(u'old_\xb5', ['old_text\n'],
 
258
                    u'new_\xe5', ['new_text\n'], output)
 
259
        self.failUnless(isinstance(output.getvalue(), str),
237
260
            'internal_diff should return bytestrings')
238
261
 
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):
 
262
 
 
263
class TestDiffFiles(TestCaseInTempDir):
304
264
 
305
265
    def test_external_diff_binary(self):
306
266
        """The output when using external diff should use diff's i18n error"""
308
268
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
309
269
 
310
270
        cmd = ['diff', '-u', '--binary', 'old', 'new']
311
 
        with open('old', 'wb') as f: f.write('\x00foobar\n')
312
 
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
 
271
        open('old', 'wb').write('\x00foobar\n')
 
272
        open('new', 'wb').write('foo\x00bar\n')
313
273
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
314
274
                                     stdin=subprocess.PIPE)
315
275
        out, err = pipe.communicate()
319
279
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
320
280
 
321
281
 
322
 
def get_diff_as_string(tree1, tree2, specific_files=None, working_tree=None):
323
 
    output = StringIO()
324
 
    if working_tree is not None:
325
 
        extra_trees = (working_tree,)
326
 
    else:
327
 
        extra_trees = ()
328
 
    diff.show_diff_trees(tree1, tree2, output,
329
 
        specific_files=specific_files,
330
 
        extra_trees=extra_trees, old_label='old/',
331
 
        new_label='new/')
332
 
    return output.getvalue()
333
 
 
334
 
 
335
 
class TestDiffDates(tests.TestCaseWithTransport):
 
282
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
283
    """Has a helper for running show_diff_trees"""
 
284
 
 
285
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
286
        output = StringIO()
 
287
        if working_tree is not None:
 
288
            extra_trees = (working_tree,)
 
289
        else:
 
290
            extra_trees = ()
 
291
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
292
                        extra_trees=extra_trees, old_label='old/',
 
293
                        new_label='new/')
 
294
        return output.getvalue()
 
295
 
 
296
 
 
297
class TestDiffDates(TestShowDiffTreesHelper):
336
298
 
337
299
    def setUp(self):
338
300
        super(TestDiffDates, self).setUp()
373
335
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
374
336
 
375
337
    def test_diff_rev_tree_working_tree(self):
376
 
        output = get_diff_as_string(self.wt.basis_tree(), self.wt)
 
338
        output = self.get_diff(self.wt.basis_tree(), self.wt)
377
339
        # note that the date for old/file1 is from rev 2 rather than from
378
340
        # the basis revision (rev 4)
379
341
        self.assertEqualDiff(output, '''\
389
351
    def test_diff_rev_tree_rev_tree(self):
390
352
        tree1 = self.b.repository.revision_tree('rev-2')
391
353
        tree2 = self.b.repository.revision_tree('rev-3')
392
 
        output = get_diff_as_string(tree1, tree2)
 
354
        output = self.get_diff(tree1, tree2)
393
355
        self.assertEqualDiff(output, '''\
394
356
=== modified file 'file2'
395
357
--- old/file2\t2006-04-01 00:00:00 +0000
399
361
+file2 contents at rev 3
400
362
 
401
363
''')
402
 
 
 
364
        
403
365
    def test_diff_add_files(self):
404
 
        tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
 
366
        tree1 = self.b.repository.revision_tree(None)
405
367
        tree2 = self.b.repository.revision_tree('rev-1')
406
 
        output = get_diff_as_string(tree1, tree2)
 
368
        output = self.get_diff(tree1, tree2)
407
369
        # the files have the epoch time stamp for the tree in which
408
370
        # they don't exist.
409
371
        self.assertEqualDiff(output, '''\
424
386
    def test_diff_remove_files(self):
425
387
        tree1 = self.b.repository.revision_tree('rev-3')
426
388
        tree2 = self.b.repository.revision_tree('rev-4')
427
 
        output = get_diff_as_string(tree1, tree2)
 
389
        output = self.get_diff(tree1, tree2)
428
390
        # the file has the epoch time stamp for the tree in which
429
391
        # it doesn't exist.
430
392
        self.assertEqualDiff(output, '''\
441
403
        self.wt.rename_one('file1', 'file1b')
442
404
        old_tree = self.b.repository.revision_tree('rev-1')
443
405
        new_tree = self.b.repository.revision_tree('rev-4')
444
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
 
406
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
445
407
                            working_tree=self.wt)
446
408
        self.assertContainsRe(out, 'file1\t')
447
409
 
453
415
        self.wt.rename_one('file1', 'dir1/file1')
454
416
        old_tree = self.b.repository.revision_tree('rev-1')
455
417
        new_tree = self.b.repository.revision_tree('rev-4')
456
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
 
418
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
457
419
                            working_tree=self.wt)
458
420
        self.assertContainsRe(out, 'file1\t')
459
 
        out = get_diff_as_string(old_tree, new_tree, specific_files=['dir2'],
 
421
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
460
422
                            working_tree=self.wt)
461
423
        self.assertNotContainsRe(out, 'file1\t')
462
424
 
463
425
 
464
 
class TestShowDiffTrees(tests.TestCaseWithTransport):
 
426
 
 
427
class TestShowDiffTrees(TestShowDiffTreesHelper):
465
428
    """Direct tests for show_diff_trees"""
466
429
 
467
430
    def test_modified_file(self):
472
435
        tree.commit('one', rev_id='rev-1')
473
436
 
474
437
        self.build_tree_contents([('tree/file', 'new contents\n')])
475
 
        d = get_diff_as_string(tree.basis_tree(), tree)
476
 
        self.assertContainsRe(d, "=== modified file 'file'\n")
477
 
        self.assertContainsRe(d, '--- old/file\t')
478
 
        self.assertContainsRe(d, '\\+\\+\\+ new/file\t')
479
 
        self.assertContainsRe(d, '-contents\n'
480
 
                                 '\\+new contents\n')
 
438
        diff = self.get_diff(tree.basis_tree(), tree)
 
439
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
440
        self.assertContainsRe(diff, '--- old/file\t')
 
441
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
442
        self.assertContainsRe(diff, '-contents\n'
 
443
                                    '\\+new contents\n')
481
444
 
482
445
    def test_modified_file_in_renamed_dir(self):
483
446
        """Test when a file is modified in a renamed directory."""
489
452
 
490
453
        tree.rename_one('dir', 'other')
491
454
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
492
 
        d = get_diff_as_string(tree.basis_tree(), tree)
493
 
        self.assertContainsRe(d, "=== renamed directory 'dir' => 'other'\n")
494
 
        self.assertContainsRe(d, "=== modified file 'other/file'\n")
 
455
        diff = self.get_diff(tree.basis_tree(), tree)
 
456
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
457
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
495
458
        # XXX: This is technically incorrect, because it used to be at another
496
459
        # location. What to do?
497
 
        self.assertContainsRe(d, '--- old/dir/file\t')
498
 
        self.assertContainsRe(d, '\\+\\+\\+ new/other/file\t')
499
 
        self.assertContainsRe(d, '-contents\n'
500
 
                                 '\\+new contents\n')
 
460
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
461
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
462
        self.assertContainsRe(diff, '-contents\n'
 
463
                                    '\\+new contents\n')
501
464
 
502
465
    def test_renamed_directory(self):
503
466
        """Test when only a directory is only renamed."""
508
471
        tree.commit('one', rev_id='rev-1')
509
472
 
510
473
        tree.rename_one('dir', 'newdir')
511
 
        d = get_diff_as_string(tree.basis_tree(), tree)
 
474
        diff = self.get_diff(tree.basis_tree(), tree)
512
475
        # Renaming a directory should be a single "you renamed this dir" even
513
476
        # when there are files inside.
514
 
        self.assertEqual(d, "=== renamed directory 'dir' => 'newdir'\n")
 
477
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
515
478
 
516
479
    def test_renamed_file(self):
517
480
        """Test when a file is only renamed."""
521
484
        tree.commit('one', rev_id='rev-1')
522
485
 
523
486
        tree.rename_one('file', 'newname')
524
 
        d = get_diff_as_string(tree.basis_tree(), tree)
525
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
 
487
        diff = self.get_diff(tree.basis_tree(), tree)
 
488
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
526
489
        # We shouldn't have a --- or +++ line, because there is no content
527
490
        # change
528
 
        self.assertNotContainsRe(d, '---')
 
491
        self.assertNotContainsRe(diff, '---')
529
492
 
530
493
    def test_renamed_and_modified_file(self):
531
494
        """Test when a file is only renamed."""
536
499
 
537
500
        tree.rename_one('file', 'newname')
538
501
        self.build_tree_contents([('tree/newname', 'new contents\n')])
539
 
        d = get_diff_as_string(tree.basis_tree(), tree)
540
 
        self.assertContainsRe(d, "=== renamed file 'file' => 'newname'\n")
541
 
        self.assertContainsRe(d, '--- old/file\t')
542
 
        self.assertContainsRe(d, '\\+\\+\\+ new/newname\t')
543
 
        self.assertContainsRe(d, '-contents\n'
544
 
                                 '\\+new contents\n')
545
 
 
546
 
 
547
 
    def test_internal_diff_exec_property(self):
548
 
        tree = self.make_branch_and_tree('tree')
549
 
 
550
 
        tt = transform.TreeTransform(tree)
551
 
        tt.new_file('a', tt.root, 'contents\n', 'a-id', True)
552
 
        tt.new_file('b', tt.root, 'contents\n', 'b-id', False)
553
 
        tt.new_file('c', tt.root, 'contents\n', 'c-id', True)
554
 
        tt.new_file('d', tt.root, 'contents\n', 'd-id', False)
555
 
        tt.new_file('e', tt.root, 'contents\n', 'control-e-id', True)
556
 
        tt.new_file('f', tt.root, 'contents\n', 'control-f-id', False)
557
 
        tt.apply()
558
 
        tree.commit('one', rev_id='rev-1')
559
 
 
560
 
        tt = transform.TreeTransform(tree)
561
 
        tt.set_executability(False, tt.trans_id_file_id('a-id'))
562
 
        tt.set_executability(True, tt.trans_id_file_id('b-id'))
563
 
        tt.set_executability(False, tt.trans_id_file_id('c-id'))
564
 
        tt.set_executability(True, tt.trans_id_file_id('d-id'))
565
 
        tt.apply()
566
 
        tree.rename_one('c', 'new-c')
567
 
        tree.rename_one('d', 'new-d')
568
 
 
569
 
        d = get_diff_as_string(tree.basis_tree(), tree)
570
 
 
571
 
        self.assertContainsRe(d, r"file 'a'.*\(properties changed:"
572
 
                                  ".*\+x to -x.*\)")
573
 
        self.assertContainsRe(d, r"file 'b'.*\(properties changed:"
574
 
                                  ".*-x to \+x.*\)")
575
 
        self.assertContainsRe(d, r"file 'c'.*\(properties changed:"
576
 
                                  ".*\+x to -x.*\)")
577
 
        self.assertContainsRe(d, r"file 'd'.*\(properties changed:"
578
 
                                  ".*-x to \+x.*\)")
579
 
        self.assertNotContainsRe(d, r"file 'e'")
580
 
        self.assertNotContainsRe(d, r"file 'f'")
 
502
        diff = self.get_diff(tree.basis_tree(), tree)
 
503
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
504
        self.assertContainsRe(diff, '--- old/file\t')
 
505
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
506
        self.assertContainsRe(diff, '-contents\n'
 
507
                                    '\\+new contents\n')
581
508
 
582
509
    def test_binary_unicode_filenames(self):
583
510
        """Test that contents of files are *not* encoded in UTF-8 when there
584
511
        is a binary file in the diff.
585
512
        """
586
513
        # See https://bugs.launchpad.net/bugs/110092.
587
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
514
        self.requireFeature(UnicodeFilename)
588
515
 
589
516
        # This bug isn't triggered with cStringIO.
590
517
        from StringIO import StringIO
598
525
        tree.add([alpha], ['file-id'])
599
526
        tree.add([omega], ['file-id-2'])
600
527
        diff_content = StringIO()
601
 
        diff.show_diff_trees(tree.basis_tree(), tree, diff_content)
602
 
        d = diff_content.getvalue()
603
 
        self.assertContainsRe(d, r"=== added file '%s'" % alpha_utf8)
604
 
        self.assertContainsRe(d, "Binary files a/%s.*and b/%s.* differ\n"
605
 
                              % (alpha_utf8, alpha_utf8))
606
 
        self.assertContainsRe(d, r"=== added file '%s'" % omega_utf8)
607
 
        self.assertContainsRe(d, r"--- a/%s" % (omega_utf8,))
608
 
        self.assertContainsRe(d, r"\+\+\+ b/%s" % (omega_utf8,))
 
528
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
529
        diff = diff_content.getvalue()
 
530
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
531
        self.assertContainsRe(
 
532
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
533
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
534
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
535
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
609
536
 
610
537
    def test_unicode_filename(self):
611
538
        """Test when the filename are unicode."""
612
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
539
        self.requireFeature(UnicodeFilename)
613
540
 
614
541
        alpha, omega = u'\u03b1', u'\u03c9'
615
542
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
630
557
        tree.add(['add_'+alpha], ['file-id'])
631
558
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
632
559
 
633
 
        d = get_diff_as_string(tree.basis_tree(), tree)
634
 
        self.assertContainsRe(d,
 
560
        diff = self.get_diff(tree.basis_tree(), tree)
 
561
        self.assertContainsRe(diff,
635
562
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
636
 
        self.assertContainsRe(d, "=== added file 'add_%s'"%autf8)
637
 
        self.assertContainsRe(d, "=== modified file 'mod_%s'"%autf8)
638
 
        self.assertContainsRe(d, "=== removed file 'del_%s'"%autf8)
639
 
 
640
 
    def test_unicode_filename_path_encoding(self):
641
 
        """Test for bug #382699: unicode filenames on Windows should be shown
642
 
        in user encoding.
643
 
        """
644
 
        self.requireFeature(features.UnicodeFilenameFeature)
645
 
        # The word 'test' in Russian
646
 
        _russian_test = u'\u0422\u0435\u0441\u0442'
647
 
        directory = _russian_test + u'/'
648
 
        test_txt = _russian_test + u'.txt'
649
 
        u1234 = u'\u1234.txt'
650
 
 
651
 
        tree = self.make_branch_and_tree('.')
652
 
        self.build_tree_contents([
653
 
            (test_txt, 'foo\n'),
654
 
            (u1234, 'foo\n'),
655
 
            (directory, None),
656
 
            ])
657
 
        tree.add([test_txt, u1234, directory])
658
 
 
659
 
        sio = StringIO()
660
 
        diff.show_diff_trees(tree.basis_tree(), tree, sio,
661
 
            path_encoding='cp1251')
662
 
 
663
 
        output = subst_dates(sio.getvalue())
664
 
        shouldbe = ('''\
665
 
=== added directory '%(directory)s'
666
 
=== added file '%(test_txt)s'
667
 
--- a/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
668
 
+++ b/%(test_txt)s\tYYYY-MM-DD HH:MM:SS +ZZZZ
669
 
@@ -0,0 +1,1 @@
670
 
+foo
671
 
 
672
 
=== added file '?.txt'
673
 
--- a/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
674
 
+++ b/?.txt\tYYYY-MM-DD HH:MM:SS +ZZZZ
675
 
@@ -0,0 +1,1 @@
676
 
+foo
677
 
 
678
 
''' % {'directory': _russian_test.encode('cp1251'),
679
 
       'test_txt': test_txt.encode('cp1251'),
680
 
      })
681
 
        self.assertEqualDiff(output, shouldbe)
682
 
 
683
 
 
684
 
class DiffWasIs(diff.DiffPath):
 
563
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
564
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
565
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
566
 
 
567
 
 
568
class DiffWasIs(DiffPath):
685
569
 
686
570
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
687
571
        self.to_file.write('was: ')
691
575
        pass
692
576
 
693
577
 
694
 
class TestDiffTree(tests.TestCaseWithTransport):
 
578
class TestDiffTree(TestCaseWithTransport):
695
579
 
696
580
    def setUp(self):
697
 
        super(TestDiffTree, self).setUp()
 
581
        TestCaseWithTransport.setUp(self)
698
582
        self.old_tree = self.make_branch_and_tree('old-tree')
699
583
        self.old_tree.lock_write()
700
584
        self.addCleanup(self.old_tree.unlock)
701
585
        self.new_tree = self.make_branch_and_tree('new-tree')
702
586
        self.new_tree.lock_write()
703
587
        self.addCleanup(self.new_tree.unlock)
704
 
        self.differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
588
        self.differ = DiffTree(self.old_tree, self.new_tree, StringIO())
705
589
 
706
590
    def test_diff_text(self):
707
591
        self.build_tree_contents([('old-tree/olddir/',),
712
596
                                  ('new-tree/newdir/newfile', 'new\n')])
713
597
        self.new_tree.add('newdir')
714
598
        self.new_tree.add('newdir/newfile', 'file-id')
715
 
        differ = diff.DiffText(self.old_tree, self.new_tree, StringIO())
 
599
        differ = DiffText(self.old_tree, self.new_tree, StringIO())
716
600
        differ.diff_text('file-id', None, 'old label', 'new label')
717
601
        self.assertEqual(
718
602
            '--- old label\n+++ new label\n@@ -1,1 +0,0 @@\n-old\n\n',
747
631
        self.assertContainsRe(self.differ.to_file.getvalue(), '\+contents')
748
632
 
749
633
    def test_diff_symlink(self):
750
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
634
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
751
635
        differ.diff_symlink('old target', None)
752
636
        self.assertEqual("=== target was 'old target'\n",
753
637
                         differ.to_file.getvalue())
754
638
 
755
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
639
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
756
640
        differ.diff_symlink(None, 'new target')
757
641
        self.assertEqual("=== target is 'new target'\n",
758
642
                         differ.to_file.getvalue())
759
643
 
760
 
        differ = diff.DiffSymlink(self.old_tree, self.new_tree, StringIO())
 
644
        differ = DiffSymlink(self.old_tree, self.new_tree, StringIO())
761
645
        differ.diff_symlink('old target', 'new target')
762
646
        self.assertEqual("=== target changed 'old target' => 'new target'\n",
763
647
                         differ.to_file.getvalue())
778
662
             ' \@\@\n-old\n\+new\n\n')
779
663
 
780
664
    def test_diff_kind_change(self):
781
 
        self.requireFeature(features.SymlinkFeature)
782
665
        self.build_tree_contents([('old-tree/olddir/',),
783
666
                                  ('old-tree/olddir/oldfile', 'old\n')])
784
667
        self.old_tree.add('olddir')
793
676
            r'--- olddir/oldfile.*\n\+\+\+ newdir/newfile.*\n\@\@ -1,1 \+0,0'
794
677
             ' \@\@\n-old\n\n')
795
678
        self.assertContainsRe(self.differ.to_file.getvalue(),
796
 
                              "=== target is u'new'\n")
 
679
                              "=== target is 'new'\n")
797
680
 
798
681
    def test_diff_directory(self):
799
682
        self.build_tree(['new-tree/new-dir/'])
813
696
 
814
697
    def test_register_diff(self):
815
698
        self.create_old_new()
816
 
        old_diff_factories = diff.DiffTree.diff_factories
817
 
        diff.DiffTree.diff_factories=old_diff_factories[:]
818
 
        diff.DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
 
699
        old_diff_factories = DiffTree.diff_factories
 
700
        DiffTree.diff_factories=old_diff_factories[:]
 
701
        DiffTree.diff_factories.insert(0, DiffWasIs.from_diff_tree)
819
702
        try:
820
 
            differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO())
 
703
            differ = DiffTree(self.old_tree, self.new_tree, StringIO())
821
704
        finally:
822
 
            diff.DiffTree.diff_factories = old_diff_factories
 
705
            DiffTree.diff_factories = old_diff_factories
823
706
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
824
707
        self.assertNotContainsRe(
825
708
            differ.to_file.getvalue(),
830
713
 
831
714
    def test_extra_factories(self):
832
715
        self.create_old_new()
833
 
        differ = diff.DiffTree(self.old_tree, self.new_tree, StringIO(),
834
 
                               extra_factories=[DiffWasIs.from_diff_tree])
 
716
        differ = DiffTree(self.old_tree, self.new_tree, StringIO(),
 
717
                            extra_factories=[DiffWasIs.from_diff_tree])
835
718
        differ.diff('file-id', 'olddir/oldfile', 'newdir/newfile')
836
719
        self.assertNotContainsRe(
837
720
            differ.to_file.getvalue(),
850
733
            '.*a-file(.|\n)*b-file')
851
734
 
852
735
 
853
 
class TestPatienceDiffLib(tests.TestCase):
 
736
class TestPatienceDiffLib(TestCase):
854
737
 
855
738
    def setUp(self):
856
739
        super(TestPatienceDiffLib, self).setUp()
857
 
        self._unique_lcs = _patiencediff_py.unique_lcs_py
858
 
        self._recurse_matches = _patiencediff_py.recurse_matches_py
 
740
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
741
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
859
742
        self._PatienceSequenceMatcher = \
860
 
            _patiencediff_py.PatienceSequenceMatcher_py
861
 
 
862
 
    def test_diff_unicode_string(self):
863
 
        a = ''.join([unichr(i) for i in range(4000, 4500, 3)])
864
 
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
865
 
        sm = self._PatienceSequenceMatcher(None, a, b)
866
 
        mb = sm.get_matching_blocks()
867
 
        self.assertEqual(35, len(mb))
 
743
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
868
744
 
869
745
    def test_unique_lcs(self):
870
746
        unique_lcs = self._unique_lcs
871
 
        self.assertEqual(unique_lcs('', ''), [])
872
 
        self.assertEqual(unique_lcs('', 'a'), [])
873
 
        self.assertEqual(unique_lcs('a', ''), [])
874
 
        self.assertEqual(unique_lcs('a', 'a'), [(0,0)])
875
 
        self.assertEqual(unique_lcs('a', 'b'), [])
876
 
        self.assertEqual(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
877
 
        self.assertEqual(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
878
 
        self.assertEqual(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
879
 
        self.assertEqual(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
747
        self.assertEquals(unique_lcs('', ''), [])
 
748
        self.assertEquals(unique_lcs('', 'a'), [])
 
749
        self.assertEquals(unique_lcs('a', ''), [])
 
750
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
 
751
        self.assertEquals(unique_lcs('a', 'b'), [])
 
752
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
 
753
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
 
754
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
 
755
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1), 
880
756
                                                         (3,3), (4,4)])
881
 
        self.assertEqual(unique_lcs('acbac', 'abc'), [(2,1)])
 
757
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
882
758
 
883
759
    def test_recurse_matches(self):
884
760
        def test_one(a, b, matches):
885
761
            test_matches = []
886
762
            self._recurse_matches(
887
763
                a, b, 0, 0, len(a), len(b), test_matches, 10)
888
 
            self.assertEqual(test_matches, matches)
 
764
            self.assertEquals(test_matches, matches)
889
765
 
890
766
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
891
767
                 [(0, 0), (2, 2), (4, 4)])
897
773
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
898
774
                                          (4, 6), (5, 7), (6, 8)])
899
775
 
900
 
        # recurse_matches doesn't match non-unique
 
776
        # recurse_matches doesn't match non-unique 
901
777
        # lines surrounded by bogus text.
902
778
        # The update has been done in patiencediff.SequenceMatcher instead
903
779
 
996
872
    def test_opcodes(self):
997
873
        def chk_ops(a, b, expected_codes):
998
874
            s = self._PatienceSequenceMatcher(None, a, b)
999
 
            self.assertEqual(expected_codes, s.get_opcodes())
 
875
            self.assertEquals(expected_codes, s.get_opcodes())
1000
876
 
1001
877
        chk_ops('', '', [])
1002
878
        chk_ops([], [], [])
1040
916
                 ('delete', 1,2, 1,1),
1041
917
                 ('equal',  2,3, 1,2),
1042
918
                ])
1043
 
        chk_ops('aBccDe', 'abccde',
 
919
        chk_ops('aBccDe', 'abccde', 
1044
920
                [('equal',   0,1, 0,1),
1045
921
                 ('replace', 1,5, 1,5),
1046
922
                 ('equal',   5,6, 5,6),
1047
923
                ])
1048
 
        chk_ops('aBcDec', 'abcdec',
 
924
        chk_ops('aBcDec', 'abcdec', 
1049
925
                [('equal',   0,1, 0,1),
1050
926
                 ('replace', 1,2, 1,2),
1051
927
                 ('equal',   2,3, 2,3),
1052
928
                 ('replace', 3,4, 3,4),
1053
929
                 ('equal',   4,6, 4,6),
1054
930
                ])
1055
 
        chk_ops('aBcdEcdFg', 'abcdecdfg',
 
931
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
1056
932
                [('equal',   0,1, 0,1),
1057
933
                 ('replace', 1,8, 1,8),
1058
934
                 ('equal',   8,9, 8,9)
1059
935
                ])
1060
 
        chk_ops('aBcdEeXcdFg', 'abcdecdfg',
 
936
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
1061
937
                [('equal',   0,1, 0,1),
1062
938
                 ('replace', 1,2, 1,2),
1063
939
                 ('equal',   2,4, 2,4),
1072
948
    def test_grouped_opcodes(self):
1073
949
        def chk_ops(a, b, expected_codes, n=3):
1074
950
            s = self._PatienceSequenceMatcher(None, a, b)
1075
 
            self.assertEqual(expected_codes, list(s.get_grouped_opcodes(n)))
 
951
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
1076
952
 
1077
953
        chk_ops('', '', [])
1078
954
        chk_ops([], [], [])
1123
999
    """
1124
1000
    gnxrf_netf = ['svyr*']
1125
1001
    gnxrf_bcgvbaf = ['ab-erphefr']
1126
 
 
 
1002
  
1127
1003
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
1128
1004
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
1129
1005
        vs vf_dhvrg():
1137
1013
'''.splitlines(True), '''\
1138
1014
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
1139
1015
 
1140
 
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl
 
1016
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
1141
1017
    nqq gurz.
1142
1018
    """
1143
1019
    gnxrf_netf = ['svyr*']
1170
1046
                 'how are you today?\n']
1171
1047
        txt_b = ['hello there\n',
1172
1048
                 'how are you today?\n']
1173
 
        unified_diff = patiencediff.unified_diff
 
1049
        unified_diff = bzrlib.patiencediff.unified_diff
1174
1050
        psm = self._PatienceSequenceMatcher
1175
 
        self.assertEqual(['--- \n',
1176
 
                           '+++ \n',
 
1051
        self.assertEquals([ '---  \n',
 
1052
                           '+++  \n',
1177
1053
                           '@@ -1,3 +1,2 @@\n',
1178
1054
                           ' hello there\n',
1179
1055
                           '-world\n',
1184
1060
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1185
1061
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1186
1062
        # This is the result with LongestCommonSubstring matching
1187
 
        self.assertEqual(['--- \n',
1188
 
                           '+++ \n',
 
1063
        self.assertEquals(['---  \n',
 
1064
                           '+++  \n',
1189
1065
                           '@@ -1,6 +1,11 @@\n',
1190
1066
                           ' a\n',
1191
1067
                           ' b\n',
1200
1076
                           ' f\n']
1201
1077
                          , list(unified_diff(txt_a, txt_b)))
1202
1078
        # And the patience diff
1203
 
        self.assertEqual(['--- \n',
1204
 
                           '+++ \n',
 
1079
        self.assertEquals(['---  \n',
 
1080
                           '+++  \n',
1205
1081
                           '@@ -4,6 +4,11 @@\n',
1206
1082
                           ' d\n',
1207
1083
                           ' e\n',
1218
1094
                          , list(unified_diff(txt_a, txt_b,
1219
1095
                                 sequencematcher=psm)))
1220
1096
 
1221
 
    def test_patience_unified_diff_with_dates(self):
1222
 
        txt_a = ['hello there\n',
1223
 
                 'world\n',
1224
 
                 'how are you today?\n']
1225
 
        txt_b = ['hello there\n',
1226
 
                 'how are you today?\n']
1227
 
        unified_diff = patiencediff.unified_diff
1228
 
        psm = self._PatienceSequenceMatcher
1229
 
        self.assertEqual(['--- a\t2008-08-08\n',
1230
 
                           '+++ b\t2008-09-09\n',
1231
 
                           '@@ -1,3 +1,2 @@\n',
1232
 
                           ' hello there\n',
1233
 
                           '-world\n',
1234
 
                           ' how are you today?\n'
1235
 
                          ]
1236
 
                          , list(unified_diff(txt_a, txt_b,
1237
 
                                 fromfile='a', tofile='b',
1238
 
                                 fromfiledate='2008-08-08',
1239
 
                                 tofiledate='2008-09-09',
1240
 
                                 sequencematcher=psm)))
1241
 
 
1242
1097
 
1243
1098
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1244
1099
 
1245
 
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1100
    _test_needs_features = [CompiledPatienceDiffFeature]
1246
1101
 
1247
1102
    def setUp(self):
1248
1103
        super(TestPatienceDiffLib_c, self).setUp()
1249
 
        from bzrlib import _patiencediff_c
1250
 
        self._unique_lcs = _patiencediff_c.unique_lcs_c
1251
 
        self._recurse_matches = _patiencediff_c.recurse_matches_c
 
1104
        import bzrlib._patiencediff_c
 
1105
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
1106
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
1252
1107
        self._PatienceSequenceMatcher = \
1253
 
            _patiencediff_c.PatienceSequenceMatcher_c
 
1108
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
1254
1109
 
1255
1110
    def test_unhashable(self):
1256
1111
        """We should get a proper exception here."""
1266
1121
                                         None, ['valid'], ['valid', []])
1267
1122
 
1268
1123
 
1269
 
class TestPatienceDiffLibFiles(tests.TestCaseInTempDir):
 
1124
class TestPatienceDiffLibFiles(TestCaseInTempDir):
1270
1125
 
1271
1126
    def setUp(self):
1272
1127
        super(TestPatienceDiffLibFiles, self).setUp()
1273
1128
        self._PatienceSequenceMatcher = \
1274
 
            _patiencediff_py.PatienceSequenceMatcher_py
 
1129
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
1275
1130
 
1276
1131
    def test_patience_unified_diff_files(self):
1277
1132
        txt_a = ['hello there\n',
1279
1134
                 'how are you today?\n']
1280
1135
        txt_b = ['hello there\n',
1281
1136
                 'how are you today?\n']
1282
 
        with open('a1', 'wb') as f: f.writelines(txt_a)
1283
 
        with open('b1', 'wb') as f: f.writelines(txt_b)
 
1137
        open('a1', 'wb').writelines(txt_a)
 
1138
        open('b1', 'wb').writelines(txt_b)
1284
1139
 
1285
 
        unified_diff_files = patiencediff.unified_diff_files
 
1140
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
1286
1141
        psm = self._PatienceSequenceMatcher
1287
 
        self.assertEqual(['--- a1\n',
1288
 
                           '+++ b1\n',
 
1142
        self.assertEquals(['--- a1 \n',
 
1143
                           '+++ b1 \n',
1289
1144
                           '@@ -1,3 +1,2 @@\n',
1290
1145
                           ' hello there\n',
1291
1146
                           '-world\n',
1296
1151
 
1297
1152
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1298
1153
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1299
 
        with open('a2', 'wb') as f: f.writelines(txt_a)
1300
 
        with open('b2', 'wb') as f: f.writelines(txt_b)
 
1154
        open('a2', 'wb').writelines(txt_a)
 
1155
        open('b2', 'wb').writelines(txt_b)
1301
1156
 
1302
1157
        # This is the result with LongestCommonSubstring matching
1303
 
        self.assertEqual(['--- a2\n',
1304
 
                           '+++ b2\n',
 
1158
        self.assertEquals(['--- a2 \n',
 
1159
                           '+++ b2 \n',
1305
1160
                           '@@ -1,6 +1,11 @@\n',
1306
1161
                           ' a\n',
1307
1162
                           ' b\n',
1317
1172
                          , list(unified_diff_files('a2', 'b2')))
1318
1173
 
1319
1174
        # And the patience diff
1320
 
        self.assertEqual(['--- a2\n',
1321
 
                          '+++ b2\n',
1322
 
                          '@@ -4,6 +4,11 @@\n',
1323
 
                          ' d\n',
1324
 
                          ' e\n',
1325
 
                          ' f\n',
1326
 
                          '+x\n',
1327
 
                          '+y\n',
1328
 
                          '+d\n',
1329
 
                          '+e\n',
1330
 
                          '+f\n',
1331
 
                          ' g\n',
1332
 
                          ' h\n',
1333
 
                          ' i\n'],
1334
 
                         list(unified_diff_files('a2', 'b2',
1335
 
                                                 sequencematcher=psm)))
 
1175
        self.assertEquals(['--- a2 \n',
 
1176
                           '+++ b2 \n',
 
1177
                           '@@ -4,6 +4,11 @@\n',
 
1178
                           ' d\n',
 
1179
                           ' e\n',
 
1180
                           ' f\n',
 
1181
                           '+x\n',
 
1182
                           '+y\n',
 
1183
                           '+d\n',
 
1184
                           '+e\n',
 
1185
                           '+f\n',
 
1186
                           ' g\n',
 
1187
                           ' h\n',
 
1188
                           ' i\n',
 
1189
                          ]
 
1190
                          , list(unified_diff_files('a2', 'b2',
 
1191
                                 sequencematcher=psm)))
1336
1192
 
1337
1193
 
1338
1194
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1339
1195
 
1340
 
    _test_needs_features = [features.compiled_patiencediff_feature]
 
1196
    _test_needs_features = [CompiledPatienceDiffFeature]
1341
1197
 
1342
1198
    def setUp(self):
1343
1199
        super(TestPatienceDiffLibFiles_c, self).setUp()
1344
 
        from bzrlib import _patiencediff_c
 
1200
        import bzrlib._patiencediff_c
1345
1201
        self._PatienceSequenceMatcher = \
1346
 
            _patiencediff_c.PatienceSequenceMatcher_c
1347
 
 
1348
 
 
1349
 
class TestUsingCompiledIfAvailable(tests.TestCase):
 
1202
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
1203
 
 
1204
 
 
1205
class TestUsingCompiledIfAvailable(TestCase):
1350
1206
 
1351
1207
    def test_PatienceSequenceMatcher(self):
1352
 
        if features.compiled_patiencediff_feature.available():
 
1208
        if CompiledPatienceDiffFeature.available():
1353
1209
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1354
1210
            self.assertIs(PatienceSequenceMatcher_c,
1355
 
                          patiencediff.PatienceSequenceMatcher)
 
1211
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1356
1212
        else:
1357
1213
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
1358
1214
            self.assertIs(PatienceSequenceMatcher_py,
1359
 
                          patiencediff.PatienceSequenceMatcher)
 
1215
                          bzrlib.patiencediff.PatienceSequenceMatcher)
1360
1216
 
1361
1217
    def test_unique_lcs(self):
1362
 
        if features.compiled_patiencediff_feature.available():
 
1218
        if CompiledPatienceDiffFeature.available():
1363
1219
            from bzrlib._patiencediff_c import unique_lcs_c
1364
1220
            self.assertIs(unique_lcs_c,
1365
 
                          patiencediff.unique_lcs)
 
1221
                          bzrlib.patiencediff.unique_lcs)
1366
1222
        else:
1367
1223
            from bzrlib._patiencediff_py import unique_lcs_py
1368
1224
            self.assertIs(unique_lcs_py,
1369
 
                          patiencediff.unique_lcs)
 
1225
                          bzrlib.patiencediff.unique_lcs)
1370
1226
 
1371
1227
    def test_recurse_matches(self):
1372
 
        if features.compiled_patiencediff_feature.available():
 
1228
        if CompiledPatienceDiffFeature.available():
1373
1229
            from bzrlib._patiencediff_c import recurse_matches_c
1374
1230
            self.assertIs(recurse_matches_c,
1375
 
                          patiencediff.recurse_matches)
 
1231
                          bzrlib.patiencediff.recurse_matches)
1376
1232
        else:
1377
1233
            from bzrlib._patiencediff_py import recurse_matches_py
1378
1234
            self.assertIs(recurse_matches_py,
1379
 
                          patiencediff.recurse_matches)
1380
 
 
1381
 
 
1382
 
class TestDiffFromTool(tests.TestCaseWithTransport):
1383
 
 
1384
 
    def test_from_string(self):
1385
 
        diff_obj = diff.DiffFromTool.from_string('diff', None, None, None)
1386
 
        self.addCleanup(diff_obj.finish)
1387
 
        self.assertEqual(['diff', '@old_path', '@new_path'],
1388
 
            diff_obj.command_template)
1389
 
 
1390
 
    def test_from_string_u5(self):
1391
 
        diff_obj = diff.DiffFromTool.from_string('diff "-u 5"',
1392
 
                                                 None, None, None)
1393
 
        self.addCleanup(diff_obj.finish)
1394
 
        self.assertEqual(['diff', '-u 5', '@old_path', '@new_path'],
1395
 
                         diff_obj.command_template)
1396
 
        self.assertEqual(['diff', '-u 5', 'old-path', 'new-path'],
1397
 
                         diff_obj._get_command('old-path', 'new-path'))
1398
 
 
1399
 
    def test_from_string_path_with_backslashes(self):
1400
 
        self.requireFeature(features.backslashdir_feature)
1401
 
        tool = 'C:\\Tools\\Diff.exe'
1402
 
        diff_obj = diff.DiffFromTool.from_string(tool, None, None, None)
1403
 
        self.addCleanup(diff_obj.finish)
1404
 
        self.assertEqual(['C:\\Tools\\Diff.exe', '@old_path', '@new_path'],
1405
 
                         diff_obj.command_template)
1406
 
        self.assertEqual(['C:\\Tools\\Diff.exe', 'old-path', 'new-path'],
1407
 
                         diff_obj._get_command('old-path', 'new-path'))
1408
 
 
1409
 
    def test_execute(self):
1410
 
        output = StringIO()
1411
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1412
 
                                      'print "@old_path @new_path"'],
1413
 
                                     None, None, output)
1414
 
        self.addCleanup(diff_obj.finish)
1415
 
        diff_obj._execute('old', 'new')
1416
 
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1417
 
 
1418
 
    def test_execute_missing(self):
1419
 
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1420
 
                                     None, None, None)
1421
 
        self.addCleanup(diff_obj.finish)
1422
 
        e = self.assertRaises(errors.ExecutableMissing, diff_obj._execute,
1423
 
                              'old', 'new')
1424
 
        self.assertEqual('a-tool-which-is-unlikely-to-exist could not be found'
1425
 
                         ' on this machine', str(e))
1426
 
 
1427
 
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1428
 
        self.requireFeature(features.AttribFeature)
1429
 
        output = StringIO()
1430
 
        tree = self.make_branch_and_tree('tree')
1431
 
        self.build_tree_contents([('tree/file', 'content')])
1432
 
        tree.add('file', 'file-id')
1433
 
        tree.commit('old tree')
1434
 
        tree.lock_read()
1435
 
        self.addCleanup(tree.unlock)
1436
 
        basis_tree = tree.basis_tree()
1437
 
        basis_tree.lock_read()
1438
 
        self.addCleanup(basis_tree.unlock)
1439
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1440
 
                                      'print "@old_path @new_path"'],
1441
 
                                     basis_tree, tree, output)
1442
 
        diff_obj._prepare_files('file-id', 'file', 'file')
1443
 
        # The old content should be readonly
1444
 
        self.assertReadableByAttrib(diff_obj._root, 'old\\file',
1445
 
                                    r'R.*old\\file$')
1446
 
        # The new content should use the tree object, not a 'new' file anymore
1447
 
        self.assertEndsWith(tree.basedir, 'work/tree')
1448
 
        self.assertReadableByAttrib(tree.basedir, 'file', r'work\\tree\\file$')
1449
 
 
1450
 
    def assertReadableByAttrib(self, cwd, relpath, regex):
1451
 
        proc = subprocess.Popen(['attrib', relpath],
1452
 
                                stdout=subprocess.PIPE,
1453
 
                                cwd=cwd)
1454
 
        (result, err) = proc.communicate()
1455
 
        self.assertContainsRe(result.replace('\r\n', '\n'), regex)
1456
 
 
1457
 
    def test_prepare_files(self):
1458
 
        output = StringIO()
1459
 
        tree = self.make_branch_and_tree('tree')
1460
 
        self.build_tree_contents([('tree/oldname', 'oldcontent')])
1461
 
        self.build_tree_contents([('tree/oldname2', 'oldcontent2')])
1462
 
        tree.add('oldname', 'file-id')
1463
 
        tree.add('oldname2', 'file2-id')
1464
 
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
1465
 
        tree.commit('old tree', timestamp=315532800)
1466
 
        tree.rename_one('oldname', 'newname')
1467
 
        tree.rename_one('oldname2', 'newname2')
1468
 
        self.build_tree_contents([('tree/newname', 'newcontent')])
1469
 
        self.build_tree_contents([('tree/newname2', 'newcontent2')])
1470
 
        old_tree = tree.basis_tree()
1471
 
        old_tree.lock_read()
1472
 
        self.addCleanup(old_tree.unlock)
1473
 
        tree.lock_read()
1474
 
        self.addCleanup(tree.unlock)
1475
 
        diff_obj = diff.DiffFromTool(['python', '-c',
1476
 
                                      'print "@old_path @new_path"'],
1477
 
                                     old_tree, tree, output)
1478
 
        self.addCleanup(diff_obj.finish)
1479
 
        self.assertContainsRe(diff_obj._root, 'bzr-diff-[^/]*')
1480
 
        old_path, new_path = diff_obj._prepare_files('file-id', 'oldname',
1481
 
                                                     'newname')
1482
 
        self.assertContainsRe(old_path, 'old/oldname$')
1483
 
        self.assertEqual(315532800, os.stat(old_path).st_mtime)
1484
 
        self.assertContainsRe(new_path, 'tree/newname$')
1485
 
        self.assertFileEqual('oldcontent', old_path)
1486
 
        self.assertFileEqual('newcontent', new_path)
1487
 
        if osutils.host_os_dereferences_symlinks():
1488
 
            self.assertTrue(os.path.samefile('tree/newname', new_path))
1489
 
        # make sure we can create files with the same parent directories
1490
 
        diff_obj._prepare_files('file2-id', 'oldname2', 'newname2')
1491
 
 
1492
 
 
1493
 
class TestDiffFromToolEncodedFilename(tests.TestCaseWithTransport):
1494
 
 
1495
 
    def test_encodable_filename(self):
1496
 
        # Just checks file path for external diff tool.
1497
 
        # We cannot change CPython's internal encoding used by os.exec*.
1498
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1499
 
                                    None, None, None)
1500
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1501
 
            encoding = scenario['encoding']
1502
 
            dirname = scenario['info']['directory']
1503
 
            filename = scenario['info']['filename']
1504
 
 
1505
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1506
 
            relpath = dirname + u'/' + filename
1507
 
            fullpath = diffobj._safe_filename('safe', relpath)
1508
 
            self.assertEqual(fullpath,
1509
 
                             fullpath.encode(encoding).decode(encoding))
1510
 
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
1511
 
 
1512
 
    def test_unencodable_filename(self):
1513
 
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1514
 
                                    None, None, None)
1515
 
        for _, scenario in EncodingAdapter.encoding_scenarios:
1516
 
            encoding = scenario['encoding']
1517
 
            dirname = scenario['info']['directory']
1518
 
            filename = scenario['info']['filename']
1519
 
 
1520
 
            if encoding == 'iso-8859-1':
1521
 
                encoding = 'iso-8859-2'
1522
 
            else:
1523
 
                encoding = 'iso-8859-1'
1524
 
 
1525
 
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1526
 
            relpath = dirname + u'/' + filename
1527
 
            fullpath = diffobj._safe_filename('safe', relpath)
1528
 
            self.assertEqual(fullpath,
1529
 
                             fullpath.encode(encoding).decode(encoding))
1530
 
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
1531
 
 
1532
 
 
1533
 
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1534
 
 
1535
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1536
 
        """Call get_trees_and_branches_to_diff_locked."""
1537
 
        return diff.get_trees_and_branches_to_diff_locked(
1538
 
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1539
 
 
1540
 
    def test_basic(self):
1541
 
        tree = self.make_branch_and_tree('tree')
1542
 
        (old_tree, new_tree,
1543
 
         old_branch, new_branch,
1544
 
         specific_files, extra_trees) = self.call_gtabtd(
1545
 
             ['tree'], None, None, None)
1546
 
 
1547
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1548
 
        self.assertEqual(_mod_revision.NULL_REVISION,
1549
 
                         old_tree.get_revision_id())
1550
 
        self.assertEqual(tree.basedir, new_tree.basedir)
1551
 
        self.assertEqual(tree.branch.base, old_branch.base)
1552
 
        self.assertEqual(tree.branch.base, new_branch.base)
1553
 
        self.assertIs(None, specific_files)
1554
 
        self.assertIs(None, extra_trees)
1555
 
 
1556
 
    def test_with_rev_specs(self):
1557
 
        tree = self.make_branch_and_tree('tree')
1558
 
        self.build_tree_contents([('tree/file', 'oldcontent')])
1559
 
        tree.add('file', 'file-id')
1560
 
        tree.commit('old tree', timestamp=0, rev_id="old-id")
1561
 
        self.build_tree_contents([('tree/file', 'newcontent')])
1562
 
        tree.commit('new tree', timestamp=0, rev_id="new-id")
1563
 
 
1564
 
        revisions = [revisionspec.RevisionSpec.from_string('1'),
1565
 
                     revisionspec.RevisionSpec.from_string('2')]
1566
 
        (old_tree, new_tree,
1567
 
         old_branch, new_branch,
1568
 
         specific_files, extra_trees) = self.call_gtabtd(
1569
 
            ['tree'], revisions, None, None)
1570
 
 
1571
 
        self.assertIsInstance(old_tree, revisiontree.RevisionTree)
1572
 
        self.assertEqual("old-id", old_tree.get_revision_id())
1573
 
        self.assertIsInstance(new_tree, revisiontree.RevisionTree)
1574
 
        self.assertEqual("new-id", new_tree.get_revision_id())
1575
 
        self.assertEqual(tree.branch.base, old_branch.base)
1576
 
        self.assertEqual(tree.branch.base, new_branch.base)
1577
 
        self.assertIs(None, specific_files)
1578
 
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
 
1235
                          bzrlib.patiencediff.recurse_matches)