← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_diff.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-09-20 02:40:52 UTC
  • mfrom: (2835.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20070920024052-y2l7r5o00zrpnr73
No longer propagate index differences automatically (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
import os
1
18
from cStringIO import StringIO
2
 
 
3
 
from bzrlib.diff import internal_diff
4
 
from bzrlib.errors import BinaryFile
5
 
from bzrlib.patiencediff import (recurse_matches, SequenceMatcher, unique_lcs,
6
 
                                 unified_diff, unified_diff_files)
7
 
from bzrlib.tests import TestCase, TestCaseInTempDir
8
 
 
 
19
import errno
 
20
import subprocess
 
21
from tempfile import TemporaryFile
 
22
 
 
23
from bzrlib.diff import internal_diff, external_diff, show_diff_trees
 
24
from bzrlib.errors import BinaryFile, NoDiff
 
25
import bzrlib.osutils as osutils
 
26
import bzrlib.patiencediff
 
27
import bzrlib._patiencediff_py
 
28
from bzrlib.tests import (Feature, TestCase, TestCaseWithTransport,
 
29
                          TestCaseInTempDir, TestSkipped)
 
30
 
 
31
 
 
32
class _CompiledPatienceDiffFeature(Feature):
 
33
 
 
34
    def _probe(self):
 
35
        try:
 
36
            import bzrlib._patiencediff_c
 
37
        except ImportError:
 
38
            return False
 
39
        return True
 
40
 
 
41
    def feature_name(self):
 
42
        return 'bzrlib._patiencediff_c'
 
43
 
 
44
CompiledPatienceDiffFeature = _CompiledPatienceDiffFeature()
 
45
 
 
46
 
 
47
class _UnicodeFilename(Feature):
 
48
    """Does the filesystem support Unicode filenames?"""
 
49
 
 
50
    def _probe(self):
 
51
        try:
 
52
            os.stat(u'\u03b1')
 
53
        except UnicodeEncodeError:
 
54
            return False
 
55
        except (IOError, OSError):
 
56
            # The filesystem allows the Unicode filename but the file doesn't
 
57
            # exist.
 
58
            return True
 
59
        else:
 
60
            # The filesystem allows the Unicode filename and the file exists,
 
61
            # for some reason.
 
62
            return True
 
63
 
 
64
UnicodeFilename = _UnicodeFilename()
 
65
 
 
66
 
 
67
class TestUnicodeFilename(TestCase):
 
68
 
 
69
    def test_probe_passes(self):
 
70
        """UnicodeFilename._probe passes."""
 
71
        # We can't test much more than that because the behaviour depends
 
72
        # on the platform.
 
73
        UnicodeFilename._probe()
 
74
        
9
75
 
10
76
def udiff_lines(old, new, allow_binary=False):
11
77
    output = StringIO()
14
80
    return output.readlines()
15
81
 
16
82
 
 
83
def external_udiff_lines(old, new, use_stringio=False):
 
84
    if use_stringio:
 
85
        # StringIO has no fileno, so it tests a different codepath
 
86
        output = StringIO()
 
87
    else:
 
88
        output = TemporaryFile()
 
89
    try:
 
90
        external_diff('old', old, 'new', new, output, diff_opts=['-u'])
 
91
    except NoDiff:
 
92
        raise TestSkipped('external "diff" not present to test')
 
93
    output.seek(0, 0)
 
94
    lines = output.readlines()
 
95
    output.close()
 
96
    return lines
 
97
 
 
98
 
17
99
class TestDiff(TestCase):
18
100
 
19
101
    def test_add_nl(self):
61
143
        udiff_lines([1023 * 'a' + '\x00'], [], allow_binary=True)
62
144
        udiff_lines([], [1023 * 'a' + '\x00'], allow_binary=True)
63
145
 
64
 
 
65
 
class TestCDVDiffLib(TestCase):
 
146
    def test_external_diff(self):
 
147
        lines = external_udiff_lines(['boo\n'], ['goo\n'])
 
148
        self.check_patch(lines)
 
149
        self.assertEqual('\n', lines[-1])
 
150
 
 
151
    def test_external_diff_no_fileno(self):
 
152
        # Make sure that we can handle not having a fileno, even
 
153
        # if the diff is large
 
154
        lines = external_udiff_lines(['boo\n']*10000,
 
155
                                     ['goo\n']*10000,
 
156
                                     use_stringio=True)
 
157
        self.check_patch(lines)
 
158
 
 
159
    def test_external_diff_binary_lang_c(self):
 
160
        old_env = {}
 
161
        for lang in ('LANG', 'LC_ALL', 'LANGUAGE'):
 
162
            old_env[lang] = osutils.set_or_unset_env(lang, 'C')
 
163
        try:
 
164
            lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
165
            # Older versions of diffutils say "Binary files", newer
 
166
            # versions just say "Files".
 
167
            self.assertContainsRe(lines[0],
 
168
                                  '(Binary f|F)iles old and new differ\n')
 
169
            self.assertEquals(lines[1:], ['\n'])
 
170
        finally:
 
171
            for lang, old_val in old_env.iteritems():
 
172
                osutils.set_or_unset_env(lang, old_val)
 
173
 
 
174
    def test_no_external_diff(self):
 
175
        """Check that NoDiff is raised when diff is not available"""
 
176
        # Use os.environ['PATH'] to make sure no 'diff' command is available
 
177
        orig_path = os.environ['PATH']
 
178
        try:
 
179
            os.environ['PATH'] = ''
 
180
            self.assertRaises(NoDiff, external_diff,
 
181
                              'old', ['boo\n'], 'new', ['goo\n'],
 
182
                              StringIO(), diff_opts=['-u'])
 
183
        finally:
 
184
            os.environ['PATH'] = orig_path
 
185
        
 
186
    def test_internal_diff_default(self):
 
187
        # Default internal diff encoding is utf8
 
188
        output = StringIO()
 
189
        internal_diff(u'old_\xb5', ['old_text\n'],
 
190
                    u'new_\xe5', ['new_text\n'], output)
 
191
        lines = output.getvalue().splitlines(True)
 
192
        self.check_patch(lines)
 
193
        self.assertEquals(['--- old_\xc2\xb5\n',
 
194
                           '+++ new_\xc3\xa5\n',
 
195
                           '@@ -1,1 +1,1 @@\n',
 
196
                           '-old_text\n',
 
197
                           '+new_text\n',
 
198
                           '\n',
 
199
                          ]
 
200
                          , lines)
 
201
 
 
202
    def test_internal_diff_utf8(self):
 
203
        output = StringIO()
 
204
        internal_diff(u'old_\xb5', ['old_text\n'],
 
205
                    u'new_\xe5', ['new_text\n'], output,
 
206
                    path_encoding='utf8')
 
207
        lines = output.getvalue().splitlines(True)
 
208
        self.check_patch(lines)
 
209
        self.assertEquals(['--- old_\xc2\xb5\n',
 
210
                           '+++ new_\xc3\xa5\n',
 
211
                           '@@ -1,1 +1,1 @@\n',
 
212
                           '-old_text\n',
 
213
                           '+new_text\n',
 
214
                           '\n',
 
215
                          ]
 
216
                          , lines)
 
217
 
 
218
    def test_internal_diff_iso_8859_1(self):
 
219
        output = StringIO()
 
220
        internal_diff(u'old_\xb5', ['old_text\n'],
 
221
                    u'new_\xe5', ['new_text\n'], output,
 
222
                    path_encoding='iso-8859-1')
 
223
        lines = output.getvalue().splitlines(True)
 
224
        self.check_patch(lines)
 
225
        self.assertEquals(['--- old_\xb5\n',
 
226
                           '+++ new_\xe5\n',
 
227
                           '@@ -1,1 +1,1 @@\n',
 
228
                           '-old_text\n',
 
229
                           '+new_text\n',
 
230
                           '\n',
 
231
                          ]
 
232
                          , lines)
 
233
 
 
234
    def test_internal_diff_returns_bytes(self):
 
235
        import StringIO
 
236
        output = StringIO.StringIO()
 
237
        internal_diff(u'old_\xb5', ['old_text\n'],
 
238
                    u'new_\xe5', ['new_text\n'], output)
 
239
        self.failUnless(isinstance(output.getvalue(), str),
 
240
            'internal_diff should return bytestrings')
 
241
 
 
242
 
 
243
class TestDiffFiles(TestCaseInTempDir):
 
244
 
 
245
    def test_external_diff_binary(self):
 
246
        """The output when using external diff should use diff's i18n error"""
 
247
        # Make sure external_diff doesn't fail in the current LANG
 
248
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
 
249
 
 
250
        cmd = ['diff', '-u', '--binary', 'old', 'new']
 
251
        open('old', 'wb').write('\x00foobar\n')
 
252
        open('new', 'wb').write('foo\x00bar\n')
 
253
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
 
254
                                     stdin=subprocess.PIPE)
 
255
        out, err = pipe.communicate()
 
256
        # Diff returns '2' on Binary files.
 
257
        self.assertEqual(2, pipe.returncode)
 
258
        # We should output whatever diff tells us, plus a trailing newline
 
259
        self.assertEqual(out.splitlines(True) + ['\n'], lines)
 
260
 
 
261
 
 
262
class TestShowDiffTreesHelper(TestCaseWithTransport):
 
263
    """Has a helper for running show_diff_trees"""
 
264
 
 
265
    def get_diff(self, tree1, tree2, specific_files=None, working_tree=None):
 
266
        output = StringIO()
 
267
        if working_tree is not None:
 
268
            extra_trees = (working_tree,)
 
269
        else:
 
270
            extra_trees = ()
 
271
        show_diff_trees(tree1, tree2, output, specific_files=specific_files,
 
272
                        extra_trees=extra_trees, old_label='old/',
 
273
                        new_label='new/')
 
274
        return output.getvalue()
 
275
 
 
276
 
 
277
class TestDiffDates(TestShowDiffTreesHelper):
 
278
 
 
279
    def setUp(self):
 
280
        super(TestDiffDates, self).setUp()
 
281
        self.wt = self.make_branch_and_tree('.')
 
282
        self.b = self.wt.branch
 
283
        self.build_tree_contents([
 
284
            ('file1', 'file1 contents at rev 1\n'),
 
285
            ('file2', 'file2 contents at rev 1\n')
 
286
            ])
 
287
        self.wt.add(['file1', 'file2'])
 
288
        self.wt.commit(
 
289
            message='Revision 1',
 
290
            timestamp=1143849600, # 2006-04-01 00:00:00 UTC
 
291
            timezone=0,
 
292
            rev_id='rev-1')
 
293
        self.build_tree_contents([('file1', 'file1 contents at rev 2\n')])
 
294
        self.wt.commit(
 
295
            message='Revision 2',
 
296
            timestamp=1143936000, # 2006-04-02 00:00:00 UTC
 
297
            timezone=28800,
 
298
            rev_id='rev-2')
 
299
        self.build_tree_contents([('file2', 'file2 contents at rev 3\n')])
 
300
        self.wt.commit(
 
301
            message='Revision 3',
 
302
            timestamp=1144022400, # 2006-04-03 00:00:00 UTC
 
303
            timezone=-3600,
 
304
            rev_id='rev-3')
 
305
        self.wt.remove(['file2'])
 
306
        self.wt.commit(
 
307
            message='Revision 4',
 
308
            timestamp=1144108800, # 2006-04-04 00:00:00 UTC
 
309
            timezone=0,
 
310
            rev_id='rev-4')
 
311
        self.build_tree_contents([
 
312
            ('file1', 'file1 contents in working tree\n')
 
313
            ])
 
314
        # set the date stamps for files in the working tree to known values
 
315
        os.utime('file1', (1144195200, 1144195200)) # 2006-04-05 00:00:00 UTC
 
316
 
 
317
    def test_diff_rev_tree_working_tree(self):
 
318
        output = self.get_diff(self.wt.basis_tree(), self.wt)
 
319
        # note that the date for old/file1 is from rev 2 rather than from
 
320
        # the basis revision (rev 4)
 
321
        self.assertEqualDiff(output, '''\
 
322
=== modified file 'file1'
 
323
--- old/file1\t2006-04-02 00:00:00 +0000
 
324
+++ new/file1\t2006-04-05 00:00:00 +0000
 
325
@@ -1,1 +1,1 @@
 
326
-file1 contents at rev 2
 
327
+file1 contents in working tree
 
328
 
 
329
''')
 
330
 
 
331
    def test_diff_rev_tree_rev_tree(self):
 
332
        tree1 = self.b.repository.revision_tree('rev-2')
 
333
        tree2 = self.b.repository.revision_tree('rev-3')
 
334
        output = self.get_diff(tree1, tree2)
 
335
        self.assertEqualDiff(output, '''\
 
336
=== modified file 'file2'
 
337
--- old/file2\t2006-04-01 00:00:00 +0000
 
338
+++ new/file2\t2006-04-03 00:00:00 +0000
 
339
@@ -1,1 +1,1 @@
 
340
-file2 contents at rev 1
 
341
+file2 contents at rev 3
 
342
 
 
343
''')
 
344
        
 
345
    def test_diff_add_files(self):
 
346
        tree1 = self.b.repository.revision_tree(None)
 
347
        tree2 = self.b.repository.revision_tree('rev-1')
 
348
        output = self.get_diff(tree1, tree2)
 
349
        # the files have the epoch time stamp for the tree in which
 
350
        # they don't exist.
 
351
        self.assertEqualDiff(output, '''\
 
352
=== added file 'file1'
 
353
--- old/file1\t1970-01-01 00:00:00 +0000
 
354
+++ new/file1\t2006-04-01 00:00:00 +0000
 
355
@@ -0,0 +1,1 @@
 
356
+file1 contents at rev 1
 
357
 
 
358
=== added file 'file2'
 
359
--- old/file2\t1970-01-01 00:00:00 +0000
 
360
+++ new/file2\t2006-04-01 00:00:00 +0000
 
361
@@ -0,0 +1,1 @@
 
362
+file2 contents at rev 1
 
363
 
 
364
''')
 
365
 
 
366
    def test_diff_remove_files(self):
 
367
        tree1 = self.b.repository.revision_tree('rev-3')
 
368
        tree2 = self.b.repository.revision_tree('rev-4')
 
369
        output = self.get_diff(tree1, tree2)
 
370
        # the file has the epoch time stamp for the tree in which
 
371
        # it doesn't exist.
 
372
        self.assertEqualDiff(output, '''\
 
373
=== removed file 'file2'
 
374
--- old/file2\t2006-04-03 00:00:00 +0000
 
375
+++ new/file2\t1970-01-01 00:00:00 +0000
 
376
@@ -1,1 +0,0 @@
 
377
-file2 contents at rev 3
 
378
 
 
379
''')
 
380
 
 
381
    def test_show_diff_specified(self):
 
382
        """A working tree filename can be used to identify a file"""
 
383
        self.wt.rename_one('file1', 'file1b')
 
384
        old_tree = self.b.repository.revision_tree('rev-1')
 
385
        new_tree = self.b.repository.revision_tree('rev-4')
 
386
        out = self.get_diff(old_tree, new_tree, specific_files=['file1b'], 
 
387
                            working_tree=self.wt)
 
388
        self.assertContainsRe(out, 'file1\t')
 
389
 
 
390
    def test_recursive_diff(self):
 
391
        """Children of directories are matched"""
 
392
        os.mkdir('dir1')
 
393
        os.mkdir('dir2')
 
394
        self.wt.add(['dir1', 'dir2'])
 
395
        self.wt.rename_one('file1', 'dir1/file1')
 
396
        old_tree = self.b.repository.revision_tree('rev-1')
 
397
        new_tree = self.b.repository.revision_tree('rev-4')
 
398
        out = self.get_diff(old_tree, new_tree, specific_files=['dir1'], 
 
399
                            working_tree=self.wt)
 
400
        self.assertContainsRe(out, 'file1\t')
 
401
        out = self.get_diff(old_tree, new_tree, specific_files=['dir2'], 
 
402
                            working_tree=self.wt)
 
403
        self.assertNotContainsRe(out, 'file1\t')
 
404
 
 
405
 
 
406
 
 
407
class TestShowDiffTrees(TestShowDiffTreesHelper):
 
408
    """Direct tests for show_diff_trees"""
 
409
 
 
410
    def test_modified_file(self):
 
411
        """Test when a file is modified."""
 
412
        tree = self.make_branch_and_tree('tree')
 
413
        self.build_tree_contents([('tree/file', 'contents\n')])
 
414
        tree.add(['file'], ['file-id'])
 
415
        tree.commit('one', rev_id='rev-1')
 
416
 
 
417
        self.build_tree_contents([('tree/file', 'new contents\n')])
 
418
        diff = self.get_diff(tree.basis_tree(), tree)
 
419
        self.assertContainsRe(diff, "=== modified file 'file'\n")
 
420
        self.assertContainsRe(diff, '--- old/file\t')
 
421
        self.assertContainsRe(diff, '\\+\\+\\+ new/file\t')
 
422
        self.assertContainsRe(diff, '-contents\n'
 
423
                                    '\\+new contents\n')
 
424
 
 
425
    def test_modified_file_in_renamed_dir(self):
 
426
        """Test when a file is modified in a renamed directory."""
 
427
        tree = self.make_branch_and_tree('tree')
 
428
        self.build_tree(['tree/dir/'])
 
429
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
 
430
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
431
        tree.commit('one', rev_id='rev-1')
 
432
 
 
433
        tree.rename_one('dir', 'other')
 
434
        self.build_tree_contents([('tree/other/file', 'new contents\n')])
 
435
        diff = self.get_diff(tree.basis_tree(), tree)
 
436
        self.assertContainsRe(diff, "=== renamed directory 'dir' => 'other'\n")
 
437
        self.assertContainsRe(diff, "=== modified file 'other/file'\n")
 
438
        # XXX: This is technically incorrect, because it used to be at another
 
439
        # location. What to do?
 
440
        self.assertContainsRe(diff, '--- old/dir/file\t')
 
441
        self.assertContainsRe(diff, '\\+\\+\\+ new/other/file\t')
 
442
        self.assertContainsRe(diff, '-contents\n'
 
443
                                    '\\+new contents\n')
 
444
 
 
445
    def test_renamed_directory(self):
 
446
        """Test when only a directory is only renamed."""
 
447
        tree = self.make_branch_and_tree('tree')
 
448
        self.build_tree(['tree/dir/'])
 
449
        self.build_tree_contents([('tree/dir/file', 'contents\n')])
 
450
        tree.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
451
        tree.commit('one', rev_id='rev-1')
 
452
 
 
453
        tree.rename_one('dir', 'newdir')
 
454
        diff = self.get_diff(tree.basis_tree(), tree)
 
455
        # Renaming a directory should be a single "you renamed this dir" even
 
456
        # when there are files inside.
 
457
        self.assertEqual("=== renamed directory 'dir' => 'newdir'\n", diff)
 
458
 
 
459
    def test_renamed_file(self):
 
460
        """Test when a file is only renamed."""
 
461
        tree = self.make_branch_and_tree('tree')
 
462
        self.build_tree_contents([('tree/file', 'contents\n')])
 
463
        tree.add(['file'], ['file-id'])
 
464
        tree.commit('one', rev_id='rev-1')
 
465
 
 
466
        tree.rename_one('file', 'newname')
 
467
        diff = self.get_diff(tree.basis_tree(), tree)
 
468
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
469
        # We shouldn't have a --- or +++ line, because there is no content
 
470
        # change
 
471
        self.assertNotContainsRe(diff, '---')
 
472
 
 
473
    def test_renamed_and_modified_file(self):
 
474
        """Test when a file is only renamed."""
 
475
        tree = self.make_branch_and_tree('tree')
 
476
        self.build_tree_contents([('tree/file', 'contents\n')])
 
477
        tree.add(['file'], ['file-id'])
 
478
        tree.commit('one', rev_id='rev-1')
 
479
 
 
480
        tree.rename_one('file', 'newname')
 
481
        self.build_tree_contents([('tree/newname', 'new contents\n')])
 
482
        diff = self.get_diff(tree.basis_tree(), tree)
 
483
        self.assertContainsRe(diff, "=== renamed file 'file' => 'newname'\n")
 
484
        self.assertContainsRe(diff, '--- old/file\t')
 
485
        self.assertContainsRe(diff, '\\+\\+\\+ new/newname\t')
 
486
        self.assertContainsRe(diff, '-contents\n'
 
487
                                    '\\+new contents\n')
 
488
 
 
489
    def test_binary_unicode_filenames(self):
 
490
        """Test that contents of files are *not* encoded in UTF-8 when there
 
491
        is a binary file in the diff.
 
492
        """
 
493
        # See https://bugs.launchpad.net/bugs/110092.
 
494
        self.requireFeature(UnicodeFilename)
 
495
 
 
496
        # This bug isn't triggered with cStringIO.
 
497
        from StringIO import StringIO
 
498
        tree = self.make_branch_and_tree('tree')
 
499
        alpha, omega = u'\u03b1', u'\u03c9'
 
500
        alpha_utf8, omega_utf8 = alpha.encode('utf8'), omega.encode('utf8')
 
501
        self.build_tree_contents(
 
502
            [('tree/' + alpha, chr(0)),
 
503
             ('tree/' + omega,
 
504
              ('The %s and the %s\n' % (alpha_utf8, omega_utf8)))])
 
505
        tree.add([alpha], ['file-id'])
 
506
        tree.add([omega], ['file-id-2'])
 
507
        diff_content = StringIO()
 
508
        show_diff_trees(tree.basis_tree(), tree, diff_content)
 
509
        diff = diff_content.getvalue()
 
510
        self.assertContainsRe(diff, r"=== added file '%s'" % alpha_utf8)
 
511
        self.assertContainsRe(
 
512
            diff, "Binary files a/%s.*and b/%s.* differ\n" % (alpha_utf8, alpha_utf8))
 
513
        self.assertContainsRe(diff, r"=== added file '%s'" % omega_utf8)
 
514
        self.assertContainsRe(diff, r"--- a/%s" % (omega_utf8,))
 
515
        self.assertContainsRe(diff, r"\+\+\+ b/%s" % (omega_utf8,))
 
516
 
 
517
    def test_unicode_filename(self):
 
518
        """Test when the filename are unicode."""
 
519
        self.requireFeature(UnicodeFilename)
 
520
 
 
521
        alpha, omega = u'\u03b1', u'\u03c9'
 
522
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
 
523
 
 
524
        tree = self.make_branch_and_tree('tree')
 
525
        self.build_tree_contents([('tree/ren_'+alpha, 'contents\n')])
 
526
        tree.add(['ren_'+alpha], ['file-id-2'])
 
527
        self.build_tree_contents([('tree/del_'+alpha, 'contents\n')])
 
528
        tree.add(['del_'+alpha], ['file-id-3'])
 
529
        self.build_tree_contents([('tree/mod_'+alpha, 'contents\n')])
 
530
        tree.add(['mod_'+alpha], ['file-id-4'])
 
531
 
 
532
        tree.commit('one', rev_id='rev-1')
 
533
 
 
534
        tree.rename_one('ren_'+alpha, 'ren_'+omega)
 
535
        tree.remove('del_'+alpha)
 
536
        self.build_tree_contents([('tree/add_'+alpha, 'contents\n')])
 
537
        tree.add(['add_'+alpha], ['file-id'])
 
538
        self.build_tree_contents([('tree/mod_'+alpha, 'contents_mod\n')])
 
539
 
 
540
        diff = self.get_diff(tree.basis_tree(), tree)
 
541
        self.assertContainsRe(diff,
 
542
                "=== renamed file 'ren_%s' => 'ren_%s'\n"%(autf8, outf8))
 
543
        self.assertContainsRe(diff, "=== added file 'add_%s'"%autf8)
 
544
        self.assertContainsRe(diff, "=== modified file 'mod_%s'"%autf8)
 
545
        self.assertContainsRe(diff, "=== removed file 'del_%s'"%autf8)
 
546
 
 
547
class TestPatienceDiffLib(TestCase):
 
548
 
 
549
    def setUp(self):
 
550
        super(TestPatienceDiffLib, self).setUp()
 
551
        self._unique_lcs = bzrlib._patiencediff_py.unique_lcs_py
 
552
        self._recurse_matches = bzrlib._patiencediff_py.recurse_matches_py
 
553
        self._PatienceSequenceMatcher = \
 
554
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
66
555
 
67
556
    def test_unique_lcs(self):
 
557
        unique_lcs = self._unique_lcs
68
558
        self.assertEquals(unique_lcs('', ''), [])
 
559
        self.assertEquals(unique_lcs('', 'a'), [])
 
560
        self.assertEquals(unique_lcs('a', ''), [])
69
561
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
70
562
        self.assertEquals(unique_lcs('a', 'b'), [])
71
563
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
78
570
    def test_recurse_matches(self):
79
571
        def test_one(a, b, matches):
80
572
            test_matches = []
81
 
            recurse_matches(a, b, len(a), len(b), test_matches, 10)
 
573
            self._recurse_matches(
 
574
                a, b, 0, 0, len(a), len(b), test_matches, 10)
82
575
            self.assertEquals(test_matches, matches)
83
576
 
84
 
        test_one(['a', None, 'b', None, 'c'], ['a', 'a', 'b', 'c', 'c'],
 
577
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
85
578
                 [(0, 0), (2, 2), (4, 4)])
86
579
        test_one(['a', 'c', 'b', 'a', 'c'], ['a', 'b', 'c'],
87
580
                 [(0, 0), (2, 1), (4, 2)])
 
581
        # Even though 'bc' is not unique globally, and is surrounded by
 
582
        # non-matching lines, we should still match, because they are locally
 
583
        # unique
 
584
        test_one('abcdbce', 'afbcgdbce', [(0,0), (1, 2), (2, 3), (3, 5),
 
585
                                          (4, 6), (5, 7), (6, 8)])
88
586
 
89
587
        # recurse_matches doesn't match non-unique 
90
588
        # lines surrounded by bogus text.
97
595
        test_one('aBccDe', 'abccde', [(0,0), (5,5)])
98
596
 
99
597
    def test_matching_blocks(self):
100
 
        def chk_blocks(a, b, matching):
 
598
        def chk_blocks(a, b, expected_blocks):
101
599
            # difflib always adds a signature of the total
102
600
            # length, with no matching entries at the end
103
 
            s = SequenceMatcher(None, a, b)
 
601
            s = self._PatienceSequenceMatcher(None, a, b)
104
602
            blocks = s.get_matching_blocks()
105
 
            x = blocks.pop()
106
 
            self.assertEquals(x, (len(a), len(b), 0))
107
 
            self.assertEquals(matching, blocks)
 
603
            self.assertEquals((len(a), len(b), 0), blocks[-1])
 
604
            self.assertEquals(expected_blocks, blocks[:-1])
108
605
 
109
606
        # Some basic matching tests
110
607
        chk_blocks('', '', [])
111
608
        chk_blocks([], [], [])
 
609
        chk_blocks('abc', '', [])
 
610
        chk_blocks('', 'abc', [])
112
611
        chk_blocks('abcd', 'abcd', [(0, 0, 4)])
113
612
        chk_blocks('abcd', 'abce', [(0, 0, 3)])
114
613
        chk_blocks('eabc', 'abce', [(1, 0, 3)])
133
632
                    'how are you today?\n'],
134
633
                [(0, 0, 1), (2, 1, 1)])
135
634
 
136
 
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (2,2,2), (5,5,1)])
137
 
 
138
 
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
139
 
                                              (5,5,2), (8,8,1)])
140
 
 
141
 
        chk_blocks('abbabbXd', 'cabbabxd', [(0,1,5), (7,7,1)])
142
 
        chk_blocks('abbabbbb', 'cabbabbc', [(0,1,6)])
143
 
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [(0,1,6)])
 
635
        # non unique lines surrounded by non-matching lines
 
636
        # won't be found
 
637
        chk_blocks('aBccDe', 'abccde', [(0,0,1), (5,5,1)])
 
638
 
 
639
        # But they only need to be locally unique
 
640
        chk_blocks('aBcDec', 'abcdec', [(0,0,1), (2,2,1), (4,4,2)])
 
641
 
 
642
        # non unique blocks won't be matched
 
643
        chk_blocks('aBcdEcdFg', 'abcdecdfg', [(0,0,1), (8,8,1)])
 
644
 
 
645
        # but locally unique ones will
 
646
        chk_blocks('aBcdEeXcdFg', 'abcdecdfg', [(0,0,1), (2,2,2),
 
647
                                              (5,4,1), (7,5,2), (10,8,1)])
 
648
 
 
649
        chk_blocks('abbabbXd', 'cabbabxd', [(7,7,1)])
 
650
        chk_blocks('abbabbbb', 'cabbabbc', [])
 
651
        chk_blocks('bbbbbbbb', 'cbbbbbbc', [])
144
652
 
145
653
    def test_opcodes(self):
146
 
        def chk_ops(a, b, codes):
147
 
            s = SequenceMatcher(None, a, b)
148
 
            self.assertEquals(codes, s.get_opcodes())
 
654
        def chk_ops(a, b, expected_codes):
 
655
            s = self._PatienceSequenceMatcher(None, a, b)
 
656
            self.assertEquals(expected_codes, s.get_opcodes())
149
657
 
150
658
        chk_ops('', '', [])
151
659
        chk_ops([], [], [])
 
660
        chk_ops('abc', '', [('delete', 0,3, 0,0)])
 
661
        chk_ops('', 'abc', [('insert', 0,0, 0,3)])
152
662
        chk_ops('abcd', 'abcd', [('equal',    0,4, 0,4)])
153
663
        chk_ops('abcd', 'abce', [('equal',   0,3, 0,3),
154
664
                                 ('replace', 3,4, 3,4)
185
695
                , 'how are you today?\n'],
186
696
                [('equal',  0,1, 0,1),
187
697
                 ('delete', 1,2, 1,1),
188
 
                 ('equal',  2,3, 1,2)
 
698
                 ('equal',  2,3, 1,2),
189
699
                ])
190
700
        chk_ops('aBccDe', 'abccde', 
191
701
                [('equal',   0,1, 0,1),
 
702
                 ('replace', 1,5, 1,5),
 
703
                 ('equal',   5,6, 5,6),
 
704
                ])
 
705
        chk_ops('aBcDec', 'abcdec', 
 
706
                [('equal',   0,1, 0,1),
192
707
                 ('replace', 1,2, 1,2),
193
 
                 ('equal',   2,4, 2,4),
194
 
                 ('replace', 4,5, 4,5),
195
 
                 ('equal',   5,6, 5,6)
 
708
                 ('equal',   2,3, 2,3),
 
709
                 ('replace', 3,4, 3,4),
 
710
                 ('equal',   4,6, 4,6),
196
711
                ])
197
712
        chk_ops('aBcdEcdFg', 'abcdecdfg', 
198
713
                [('equal',   0,1, 0,1),
199
 
                 ('replace', 1,2, 1,2),
200
 
                 ('equal',   2,4, 2,4),
201
 
                 ('replace', 4,5, 4,5),
202
 
                 ('equal',   5,7, 5,7),
203
 
                 ('replace', 7,8, 7,8),
 
714
                 ('replace', 1,8, 1,8),
204
715
                 ('equal',   8,9, 8,9)
205
716
                ])
 
717
        chk_ops('aBcdEeXcdFg', 'abcdecdfg', 
 
718
                [('equal',   0,1, 0,1),
 
719
                 ('replace', 1,2, 1,2),
 
720
                 ('equal',   2,4, 2,4),
 
721
                 ('delete', 4,5, 4,4),
 
722
                 ('equal',   5,6, 4,5),
 
723
                 ('delete', 6,7, 5,5),
 
724
                 ('equal',   7,9, 5,7),
 
725
                 ('replace', 9,10, 7,8),
 
726
                 ('equal',   10,11, 8,9)
 
727
                ])
 
728
 
 
729
    def test_grouped_opcodes(self):
 
730
        def chk_ops(a, b, expected_codes, n=3):
 
731
            s = self._PatienceSequenceMatcher(None, a, b)
 
732
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
 
733
 
 
734
        chk_ops('', '', [])
 
735
        chk_ops([], [], [])
 
736
        chk_ops('abc', '', [[('delete', 0,3, 0,0)]])
 
737
        chk_ops('', 'abc', [[('insert', 0,0, 0,3)]])
 
738
        chk_ops('abcd', 'abcd', [])
 
739
        chk_ops('abcd', 'abce', [[('equal',   0,3, 0,3),
 
740
                                  ('replace', 3,4, 3,4)
 
741
                                 ]])
 
742
        chk_ops('eabc', 'abce', [[('delete', 0,1, 0,0),
 
743
                                 ('equal',  1,4, 0,3),
 
744
                                 ('insert', 4,4, 3,4)
 
745
                                ]])
 
746
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
747
                [[('equal',  3,6, 3,6),
 
748
                  ('insert', 6,6, 6,11),
 
749
                  ('equal',  6,9, 11,14)
 
750
                  ]])
 
751
        chk_ops('abcdefghijklmnop', 'abcdefxydefghijklmnop',
 
752
                [[('equal',  2,6, 2,6),
 
753
                  ('insert', 6,6, 6,11),
 
754
                  ('equal',  6,10, 11,15)
 
755
                  ]], 4)
 
756
        chk_ops('Xabcdef', 'abcdef',
 
757
                [[('delete', 0,1, 0,0),
 
758
                  ('equal',  1,4, 0,3)
 
759
                  ]])
 
760
        chk_ops('abcdef', 'abcdefX',
 
761
                [[('equal',  3,6, 3,6),
 
762
                  ('insert', 6,6, 6,7)
 
763
                  ]])
 
764
 
206
765
 
207
766
    def test_multiple_ranges(self):
208
767
        # There was an earlier bug where we used a bad set of ranges,
209
768
        # this triggers that specific bug, to make sure it doesn't regress
210
 
        def chk_blocks(a, b, matching):
 
769
        def chk_blocks(a, b, expected_blocks):
211
770
            # difflib always adds a signature of the total
212
771
            # length, with no matching entries at the end
213
 
            s = SequenceMatcher(None, a, b)
 
772
            s = self._PatienceSequenceMatcher(None, a, b)
214
773
            blocks = s.get_matching_blocks()
215
774
            x = blocks.pop()
216
775
            self.assertEquals(x, (len(a), len(b), 0))
217
 
            self.assertEquals(matching, blocks)
 
776
            self.assertEquals(expected_blocks, blocks)
218
777
 
219
778
        chk_blocks('abcdefghijklmnop'
220
779
                 , 'abcXghiYZQRSTUVWXYZijklmnop'
222
781
 
223
782
        chk_blocks('ABCd efghIjk  L'
224
783
                 , 'AxyzBCn mo pqrstuvwI1 2  L'
225
 
                 , [(0,0,1), (1, 4, 2), (4, 7, 1), (9, 19, 1), (12, 23, 3)])
 
784
                 , [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
226
785
 
 
786
        # These are rot13 code snippets.
227
787
        chk_blocks('''\
228
 
    get added when you add a file in the directory.
229
 
    """
230
 
    takes_args = ['file*']
231
 
    takes_options = ['no-recurse']
232
 
    
233
 
    def run(self, file_list, no_recurse=False):
234
 
        from bzrlib.add import smart_add, add_reporter_print, add_reporter_null
235
 
        if is_quiet():
236
 
            reporter = add_reporter_null
237
 
        else:
238
 
            reporter = add_reporter_print
239
 
        smart_add(file_list, not no_recurse, reporter)
240
 
 
241
 
 
242
 
class cmd_mkdir(Command):
243
 
'''.splitlines(True)
244
 
, '''\
245
 
    get added when you add a file in the directory.
246
 
 
247
 
    --dry-run will show which files would be added, but not actually 
248
 
    add them.
249
 
    """
250
 
    takes_args = ['file*']
251
 
    takes_options = ['no-recurse', 'dry-run']
252
 
 
253
 
    def run(self, file_list, no_recurse=False, dry_run=False):
254
 
        import bzrlib.add
255
 
 
256
 
        if dry_run:
257
 
            if is_quiet():
258
 
                # This is pointless, but I'd rather not raise an error
259
 
                action = bzrlib.add.add_action_null
260
 
            else:
261
 
                action = bzrlib.add.add_action_print
262
 
        elif is_quiet():
263
 
            action = bzrlib.add.add_action_add
264
 
        else:
265
 
            action = bzrlib.add.add_action_add_and_print
266
 
 
267
 
        bzrlib.add.smart_add(file_list, not no_recurse, action)
268
 
 
269
 
 
270
 
class cmd_mkdir(Command):
 
788
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
 
789
    """
 
790
    gnxrf_netf = ['svyr*']
 
791
    gnxrf_bcgvbaf = ['ab-erphefr']
 
792
  
 
793
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr):
 
794
        sebz omeyvo.nqq vzcbeg fzneg_nqq, nqq_ercbegre_cevag, nqq_ercbegre_ahyy
 
795
        vs vf_dhvrg():
 
796
            ercbegre = nqq_ercbegre_ahyy
 
797
        ryfr:
 
798
            ercbegre = nqq_ercbegre_cevag
 
799
        fzneg_nqq(svyr_yvfg, abg ab_erphefr, ercbegre)
 
800
 
 
801
 
 
802
pynff pzq_zxqve(Pbzznaq):
 
803
'''.splitlines(True), '''\
 
804
    trg nqqrq jura lbh nqq n svyr va gur qverpgbel.
 
805
 
 
806
    --qel-eha jvyy fubj juvpu svyrf jbhyq or nqqrq, ohg abg npghnyyl 
 
807
    nqq gurz.
 
808
    """
 
809
    gnxrf_netf = ['svyr*']
 
810
    gnxrf_bcgvbaf = ['ab-erphefr', 'qel-eha']
 
811
 
 
812
    qrs eha(frys, svyr_yvfg, ab_erphefr=Snyfr, qel_eha=Snyfr):
 
813
        vzcbeg omeyvo.nqq
 
814
 
 
815
        vs qel_eha:
 
816
            vs vf_dhvrg():
 
817
                # Guvf vf cbvagyrff, ohg V'q engure abg envfr na reebe
 
818
                npgvba = omeyvo.nqq.nqq_npgvba_ahyy
 
819
            ryfr:
 
820
  npgvba = omeyvo.nqq.nqq_npgvba_cevag
 
821
        ryvs vf_dhvrg():
 
822
            npgvba = omeyvo.nqq.nqq_npgvba_nqq
 
823
        ryfr:
 
824
       npgvba = omeyvo.nqq.nqq_npgvba_nqq_naq_cevag
 
825
 
 
826
        omeyvo.nqq.fzneg_nqq(svyr_yvfg, abg ab_erphefr, npgvba)
 
827
 
 
828
 
 
829
pynff pzq_zxqve(Pbzznaq):
271
830
'''.splitlines(True)
272
831
, [(0,0,1), (1, 4, 2), (9, 19, 1), (12, 23, 3)])
273
832
 
274
 
    def test_cdv_unified_diff(self):
 
833
    def test_patience_unified_diff(self):
275
834
        txt_a = ['hello there\n',
276
835
                 'world\n',
277
836
                 'how are you today?\n']
278
837
        txt_b = ['hello there\n',
279
838
                 'how are you today?\n']
 
839
        unified_diff = bzrlib.patiencediff.unified_diff
 
840
        psm = self._PatienceSequenceMatcher
280
841
        self.assertEquals([ '---  \n',
281
842
                           '+++  \n',
282
843
                           '@@ -1,3 +1,2 @@\n',
284
845
                           '-world\n',
285
846
                           ' how are you today?\n'
286
847
                          ]
287
 
                          , list(unified_diff(txt_a, txt_b
288
 
                                        , sequencematcher=SequenceMatcher)))
 
848
                          , list(unified_diff(txt_a, txt_b,
 
849
                                 sequencematcher=psm)))
289
850
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
290
851
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
291
852
        # This is the result with LongestCommonSubstring matching
304
865
                           ' e\n',
305
866
                           ' f\n']
306
867
                          , list(unified_diff(txt_a, txt_b)))
307
 
        # And the cdv diff
 
868
        # And the patience diff
308
869
        self.assertEquals(['---  \n',
309
870
                           '+++  \n',
310
871
                           '@@ -4,6 +4,11 @@\n',
321
882
                           ' i\n',
322
883
                          ]
323
884
                          , list(unified_diff(txt_a, txt_b,
324
 
                                 sequencematcher=SequenceMatcher)))
325
 
 
326
 
 
327
 
class TestCDVDiffLibFiles(TestCaseInTempDir):
328
 
 
329
 
    def test_cdv_unified_diff_files(self):
 
885
                                 sequencematcher=psm)))
 
886
 
 
887
 
 
888
class TestPatienceDiffLib_c(TestPatienceDiffLib):
 
889
 
 
890
    _test_needs_features = [CompiledPatienceDiffFeature]
 
891
 
 
892
    def setUp(self):
 
893
        super(TestPatienceDiffLib_c, self).setUp()
 
894
        import bzrlib._patiencediff_c
 
895
        self._unique_lcs = bzrlib._patiencediff_c.unique_lcs_c
 
896
        self._recurse_matches = bzrlib._patiencediff_c.recurse_matches_c
 
897
        self._PatienceSequenceMatcher = \
 
898
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
899
 
 
900
 
 
901
class TestPatienceDiffLibFiles(TestCaseInTempDir):
 
902
 
 
903
    def setUp(self):
 
904
        super(TestPatienceDiffLibFiles, self).setUp()
 
905
        self._PatienceSequenceMatcher = \
 
906
            bzrlib._patiencediff_py.PatienceSequenceMatcher_py
 
907
 
 
908
    def test_patience_unified_diff_files(self):
330
909
        txt_a = ['hello there\n',
331
910
                 'world\n',
332
911
                 'how are you today?\n']
335
914
        open('a1', 'wb').writelines(txt_a)
336
915
        open('b1', 'wb').writelines(txt_b)
337
916
 
 
917
        unified_diff_files = bzrlib.patiencediff.unified_diff_files
 
918
        psm = self._PatienceSequenceMatcher
338
919
        self.assertEquals(['--- a1 \n',
339
920
                           '+++ b1 \n',
340
921
                           '@@ -1,3 +1,2 @@\n',
343
924
                           ' how are you today?\n',
344
925
                          ]
345
926
                          , list(unified_diff_files('a1', 'b1',
346
 
                                 sequencematcher=SequenceMatcher)))
 
927
                                 sequencematcher=psm)))
347
928
 
348
929
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
349
930
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
367
948
                           ' f\n']
368
949
                          , list(unified_diff_files('a2', 'b2')))
369
950
 
370
 
        # And the cdv diff
 
951
        # And the patience diff
371
952
        self.assertEquals(['--- a2 \n',
372
953
                           '+++ b2 \n',
373
954
                           '@@ -4,6 +4,11 @@\n',
384
965
                           ' i\n',
385
966
                          ]
386
967
                          , list(unified_diff_files('a2', 'b2',
387
 
                                 sequencematcher=SequenceMatcher)))
 
968
                                 sequencematcher=psm)))
 
969
 
 
970
 
 
971
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
 
972
 
 
973
    _test_needs_features = [CompiledPatienceDiffFeature]
 
974
 
 
975
    def setUp(self):
 
976
        super(TestPatienceDiffLibFiles_c, self).setUp()
 
977
        import bzrlib._patiencediff_c
 
978
        self._PatienceSequenceMatcher = \
 
979
            bzrlib._patiencediff_c.PatienceSequenceMatcher_c
 
980
 
 
981
 
 
982
class TestUsingCompiledIfAvailable(TestCase):
 
983
 
 
984
    def test_PatienceSequenceMatcher(self):
 
985
        if CompiledPatienceDiffFeature.available():
 
986
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
 
987
            self.assertIs(PatienceSequenceMatcher_c,
 
988
                          bzrlib.patiencediff.PatienceSequenceMatcher)
 
989
        else:
 
990
            from bzrlib._patiencediff_py import PatienceSequenceMatcher_py
 
991
            self.assertIs(PatienceSequenceMatcher_py,
 
992
                          bzrlib.patiencediff.PatienceSequenceMatcher)
 
993
 
 
994
    def test_unique_lcs(self):
 
995
        if CompiledPatienceDiffFeature.available():
 
996
            from bzrlib._patiencediff_c import unique_lcs_c
 
997
            self.assertIs(unique_lcs_c,
 
998
                          bzrlib.patiencediff.unique_lcs)
 
999
        else:
 
1000
            from bzrlib._patiencediff_py import unique_lcs_py
 
1001
            self.assertIs(unique_lcs_py,
 
1002
                          bzrlib.patiencediff.unique_lcs)
 
1003
 
 
1004
    def test_recurse_matches(self):
 
1005
        if CompiledPatienceDiffFeature.available():
 
1006
            from bzrlib._patiencediff_c import recurse_matches_c
 
1007
            self.assertIs(recurse_matches_c,
 
1008
                          bzrlib.patiencediff.recurse_matches)
 
1009
        else:
 
1010
            from bzrlib._patiencediff_py import recurse_matches_py
 
1011
            self.assertIs(recurse_matches_py,
 
1012
                          bzrlib.patiencediff.recurse_matches)