← 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: Jelmer Vernooij
  • Date: 2016-04-03 16:32:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6617.
  • Revision ID: jelmer@jelmer.uk-20160403163231-h72bo0uyek2gikw0
https://launchpad.net/bugs/1565503
Don't put French text in doc/en/user-reference when LANGUAGE=fr_CH.UTF_8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_diff.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2014, 2016 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
17
17
import os
18
18
from cStringIO import StringIO
19
19
import subprocess
20
 
import sys
21
20
import tempfile
22
21
 
23
22
from bzrlib import (
32
31
    tests,
33
32
    transform,
34
33
    )
35
 
from bzrlib.symbol_versioning import deprecated_in
36
 
from bzrlib.tests import features, EncodingAdapter
 
34
from bzrlib.tests import (
 
35
    features,
 
36
    EncodingAdapter,
 
37
)
37
38
from bzrlib.tests.blackbox.test_diff import subst_dates
38
 
 
39
 
 
40
 
class _AttribFeature(tests.Feature):
41
 
 
42
 
    def _probe(self):
43
 
        if (sys.platform not in ('cygwin', 'win32')):
44
 
            return False
45
 
        try:
46
 
            proc = subprocess.Popen(['attrib', '.'], stdout=subprocess.PIPE)
47
 
        except OSError, e:
48
 
            return False
49
 
        return (0 == proc.wait())
50
 
 
51
 
    def feature_name(self):
52
 
        return 'attrib Windows command-line tool'
53
 
 
54
 
AttribFeature = _AttribFeature()
55
 
 
56
 
 
57
 
compiled_patiencediff_feature = tests.ModuleAvailableFeature(
58
 
                                    'bzrlib._patiencediff_c')
 
39
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
40
 
 
41
 
 
42
load_tests = load_tests_apply_scenarios
59
43
 
60
44
 
61
45
def udiff_lines(old, new, allow_binary=False):
81
65
    return lines
82
66
 
83
67
 
 
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
 
84
91
class TestDiff(tests.TestCase):
85
92
 
86
93
    def test_add_nl(self):
87
94
        """diff generates a valid diff for patches that add a newline"""
88
95
        lines = udiff_lines(['boo'], ['boo\n'])
89
96
        self.check_patch(lines)
90
 
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
 
97
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
91
98
            ## "expected no-nl, got %r" % lines[4]
92
99
 
93
100
    def test_add_nl_2(self):
96
103
        """
97
104
        lines = udiff_lines(['boo'], ['goo\n'])
98
105
        self.check_patch(lines)
99
 
        self.assertEquals(lines[4], '\\ No newline at end of file\n')
 
106
        self.assertEqual(lines[4], '\\ No newline at end of file\n')
100
107
            ## "expected no-nl, got %r" % lines[4]
101
108
 
102
109
    def test_remove_nl(self):
105
112
        """
106
113
        lines = udiff_lines(['boo\n'], ['boo'])
107
114
        self.check_patch(lines)
108
 
        self.assertEquals(lines[5], '\\ No newline at end of file\n')
 
115
        self.assertEqual(lines[5], '\\ No newline at end of file\n')
109
116
            ## "expected no-nl, got %r" % lines[5]
110
117
 
111
118
    def check_patch(self, lines):
112
 
        self.assert_(len(lines) > 1)
 
119
        self.assertTrue(len(lines) > 1)
113
120
            ## "Not enough lines for a file header for patch:\n%s" % "".join(lines)
114
 
        self.assert_(lines[0].startswith ('---'))
 
121
        self.assertTrue(lines[0].startswith ('---'))
115
122
            ## 'No orig line for patch:\n%s' % "".join(lines)
116
 
        self.assert_(lines[1].startswith ('+++'))
 
123
        self.assertTrue(lines[1].startswith ('+++'))
117
124
            ## 'No mod line for patch:\n%s' % "".join(lines)
118
 
        self.assert_(len(lines) > 2)
 
125
        self.assertTrue(len(lines) > 2)
119
126
            ## "No hunks for patch:\n%s" % "".join(lines)
120
 
        self.assert_(lines[2].startswith('@@'))
 
127
        self.assertTrue(lines[2].startswith('@@'))
121
128
            ## "No hunk header for patch:\n%s" % "".join(lines)
122
 
        self.assert_('@@' in lines[2][2:])
 
129
        self.assertTrue('@@' in lines[2][2:])
123
130
            ## "Unterminated hunk header for patch:\n%s" % "".join(lines)
124
131
 
125
132
    def test_binary_lines(self):
150
157
        # Older versions of diffutils say "Binary files", newer
151
158
        # versions just say "Files".
152
159
        self.assertContainsRe(lines[0], '(Binary f|F)iles old and new differ\n')
153
 
        self.assertEquals(lines[1:], ['\n'])
 
160
        self.assertEqual(lines[1:], ['\n'])
154
161
 
155
162
    def test_no_external_diff(self):
156
163
        """Check that NoDiff is raised when diff is not available"""
168
175
                           u'new_\xe5', ['new_text\n'], output)
169
176
        lines = output.getvalue().splitlines(True)
170
177
        self.check_patch(lines)
171
 
        self.assertEquals(['--- old_\xc2\xb5\n',
 
178
        self.assertEqual(['--- old_\xc2\xb5\n',
172
179
                           '+++ new_\xc3\xa5\n',
173
180
                           '@@ -1,1 +1,1 @@\n',
174
181
                           '-old_text\n',
184
191
                           path_encoding='utf8')
185
192
        lines = output.getvalue().splitlines(True)
186
193
        self.check_patch(lines)
187
 
        self.assertEquals(['--- old_\xc2\xb5\n',
 
194
        self.assertEqual(['--- old_\xc2\xb5\n',
188
195
                           '+++ new_\xc3\xa5\n',
189
196
                           '@@ -1,1 +1,1 @@\n',
190
197
                           '-old_text\n',
200
207
                           path_encoding='iso-8859-1')
201
208
        lines = output.getvalue().splitlines(True)
202
209
        self.check_patch(lines)
203
 
        self.assertEquals(['--- old_\xb5\n',
 
210
        self.assertEqual(['--- old_\xb5\n',
204
211
                           '+++ new_\xe5\n',
205
212
                           '@@ -1,1 +1,1 @@\n',
206
213
                           '-old_text\n',
229
236
        self.assertIsInstance(output.getvalue(), str,
230
237
            'internal_diff should return bytestrings')
231
238
 
 
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
 
232
302
 
233
303
class TestDiffFiles(tests.TestCaseInTempDir):
234
304
 
238
308
        lines = external_udiff_lines(['\x00foobar\n'], ['foo\x00bar\n'])
239
309
 
240
310
        cmd = ['diff', '-u', '--binary', 'old', 'new']
241
 
        open('old', 'wb').write('\x00foobar\n')
242
 
        open('new', 'wb').write('foo\x00bar\n')
 
311
        with open('old', 'wb') as f: f.write('\x00foobar\n')
 
312
        with open('new', 'wb') as f: f.write('foo\x00bar\n')
243
313
        pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE,
244
314
                                     stdin=subprocess.PIPE)
245
315
        out, err = pipe.communicate()
514
584
        is a binary file in the diff.
515
585
        """
516
586
        # See https://bugs.launchpad.net/bugs/110092.
517
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
587
        self.requireFeature(features.UnicodeFilenameFeature)
518
588
 
519
589
        # This bug isn't triggered with cStringIO.
520
590
        from StringIO import StringIO
539
609
 
540
610
    def test_unicode_filename(self):
541
611
        """Test when the filename are unicode."""
542
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
612
        self.requireFeature(features.UnicodeFilenameFeature)
543
613
 
544
614
        alpha, omega = u'\u03b1', u'\u03c9'
545
615
        autf8, outf8 = alpha.encode('utf8'), omega.encode('utf8')
571
641
        """Test for bug #382699: unicode filenames on Windows should be shown
572
642
        in user encoding.
573
643
        """
574
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
644
        self.requireFeature(features.UnicodeFilenameFeature)
575
645
        # The word 'test' in Russian
576
646
        _russian_test = u'\u0422\u0435\u0441\u0442'
577
647
        directory = _russian_test + u'/'
708
778
             ' \@\@\n-old\n\+new\n\n')
709
779
 
710
780
    def test_diff_kind_change(self):
711
 
        self.requireFeature(tests.SymlinkFeature)
 
781
        self.requireFeature(features.SymlinkFeature)
712
782
        self.build_tree_contents([('old-tree/olddir/',),
713
783
                                  ('old-tree/olddir/oldfile', 'old\n')])
714
784
        self.old_tree.add('olddir')
794
864
        b = ''.join([unichr(i) for i in range(4300, 4800, 2)])
795
865
        sm = self._PatienceSequenceMatcher(None, a, b)
796
866
        mb = sm.get_matching_blocks()
797
 
        self.assertEquals(35, len(mb))
 
867
        self.assertEqual(35, len(mb))
798
868
 
799
869
    def test_unique_lcs(self):
800
870
        unique_lcs = self._unique_lcs
801
 
        self.assertEquals(unique_lcs('', ''), [])
802
 
        self.assertEquals(unique_lcs('', 'a'), [])
803
 
        self.assertEquals(unique_lcs('a', ''), [])
804
 
        self.assertEquals(unique_lcs('a', 'a'), [(0,0)])
805
 
        self.assertEquals(unique_lcs('a', 'b'), [])
806
 
        self.assertEquals(unique_lcs('ab', 'ab'), [(0,0), (1,1)])
807
 
        self.assertEquals(unique_lcs('abcde', 'cdeab'), [(2,0), (3,1), (4,2)])
808
 
        self.assertEquals(unique_lcs('cdeab', 'abcde'), [(0,2), (1,3), (2,4)])
809
 
        self.assertEquals(unique_lcs('abXde', 'abYde'), [(0,0), (1,1),
 
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),
810
880
                                                         (3,3), (4,4)])
811
 
        self.assertEquals(unique_lcs('acbac', 'abc'), [(2,1)])
 
881
        self.assertEqual(unique_lcs('acbac', 'abc'), [(2,1)])
812
882
 
813
883
    def test_recurse_matches(self):
814
884
        def test_one(a, b, matches):
815
885
            test_matches = []
816
886
            self._recurse_matches(
817
887
                a, b, 0, 0, len(a), len(b), test_matches, 10)
818
 
            self.assertEquals(test_matches, matches)
 
888
            self.assertEqual(test_matches, matches)
819
889
 
820
890
        test_one(['a', '', 'b', '', 'c'], ['a', 'a', 'b', 'c', 'c'],
821
891
                 [(0, 0), (2, 2), (4, 4)])
926
996
    def test_opcodes(self):
927
997
        def chk_ops(a, b, expected_codes):
928
998
            s = self._PatienceSequenceMatcher(None, a, b)
929
 
            self.assertEquals(expected_codes, s.get_opcodes())
 
999
            self.assertEqual(expected_codes, s.get_opcodes())
930
1000
 
931
1001
        chk_ops('', '', [])
932
1002
        chk_ops([], [], [])
1002
1072
    def test_grouped_opcodes(self):
1003
1073
        def chk_ops(a, b, expected_codes, n=3):
1004
1074
            s = self._PatienceSequenceMatcher(None, a, b)
1005
 
            self.assertEquals(expected_codes, list(s.get_grouped_opcodes(n)))
 
1075
            self.assertEqual(expected_codes, list(s.get_grouped_opcodes(n)))
1006
1076
 
1007
1077
        chk_ops('', '', [])
1008
1078
        chk_ops([], [], [])
1102
1172
                 'how are you today?\n']
1103
1173
        unified_diff = patiencediff.unified_diff
1104
1174
        psm = self._PatienceSequenceMatcher
1105
 
        self.assertEquals(['--- \n',
 
1175
        self.assertEqual(['--- \n',
1106
1176
                           '+++ \n',
1107
1177
                           '@@ -1,3 +1,2 @@\n',
1108
1178
                           ' hello there\n',
1114
1184
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1115
1185
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1116
1186
        # This is the result with LongestCommonSubstring matching
1117
 
        self.assertEquals(['--- \n',
 
1187
        self.assertEqual(['--- \n',
1118
1188
                           '+++ \n',
1119
1189
                           '@@ -1,6 +1,11 @@\n',
1120
1190
                           ' a\n',
1130
1200
                           ' f\n']
1131
1201
                          , list(unified_diff(txt_a, txt_b)))
1132
1202
        # And the patience diff
1133
 
        self.assertEquals(['--- \n',
 
1203
        self.assertEqual(['--- \n',
1134
1204
                           '+++ \n',
1135
1205
                           '@@ -4,6 +4,11 @@\n',
1136
1206
                           ' d\n',
1156
1226
                 'how are you today?\n']
1157
1227
        unified_diff = patiencediff.unified_diff
1158
1228
        psm = self._PatienceSequenceMatcher
1159
 
        self.assertEquals(['--- a\t2008-08-08\n',
 
1229
        self.assertEqual(['--- a\t2008-08-08\n',
1160
1230
                           '+++ b\t2008-09-09\n',
1161
1231
                           '@@ -1,3 +1,2 @@\n',
1162
1232
                           ' hello there\n',
1172
1242
 
1173
1243
class TestPatienceDiffLib_c(TestPatienceDiffLib):
1174
1244
 
1175
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1245
    _test_needs_features = [features.compiled_patiencediff_feature]
1176
1246
 
1177
1247
    def setUp(self):
1178
1248
        super(TestPatienceDiffLib_c, self).setUp()
1209
1279
                 'how are you today?\n']
1210
1280
        txt_b = ['hello there\n',
1211
1281
                 'how are you today?\n']
1212
 
        open('a1', 'wb').writelines(txt_a)
1213
 
        open('b1', 'wb').writelines(txt_b)
 
1282
        with open('a1', 'wb') as f: f.writelines(txt_a)
 
1283
        with open('b1', 'wb') as f: f.writelines(txt_b)
1214
1284
 
1215
1285
        unified_diff_files = patiencediff.unified_diff_files
1216
1286
        psm = self._PatienceSequenceMatcher
1217
 
        self.assertEquals(['--- a1\n',
 
1287
        self.assertEqual(['--- a1\n',
1218
1288
                           '+++ b1\n',
1219
1289
                           '@@ -1,3 +1,2 @@\n',
1220
1290
                           ' hello there\n',
1226
1296
 
1227
1297
        txt_a = map(lambda x: x+'\n', 'abcdefghijklmnop')
1228
1298
        txt_b = map(lambda x: x+'\n', 'abcdefxydefghijklmnop')
1229
 
        open('a2', 'wb').writelines(txt_a)
1230
 
        open('b2', 'wb').writelines(txt_b)
 
1299
        with open('a2', 'wb') as f: f.writelines(txt_a)
 
1300
        with open('b2', 'wb') as f: f.writelines(txt_b)
1231
1301
 
1232
1302
        # This is the result with LongestCommonSubstring matching
1233
 
        self.assertEquals(['--- a2\n',
 
1303
        self.assertEqual(['--- a2\n',
1234
1304
                           '+++ b2\n',
1235
1305
                           '@@ -1,6 +1,11 @@\n',
1236
1306
                           ' a\n',
1247
1317
                          , list(unified_diff_files('a2', 'b2')))
1248
1318
 
1249
1319
        # And the patience diff
1250
 
        self.assertEquals(['--- a2\n',
1251
 
                           '+++ b2\n',
1252
 
                           '@@ -4,6 +4,11 @@\n',
1253
 
                           ' d\n',
1254
 
                           ' e\n',
1255
 
                           ' f\n',
1256
 
                           '+x\n',
1257
 
                           '+y\n',
1258
 
                           '+d\n',
1259
 
                           '+e\n',
1260
 
                           '+f\n',
1261
 
                           ' g\n',
1262
 
                           ' h\n',
1263
 
                           ' i\n',
1264
 
                          ]
1265
 
                          , list(unified_diff_files('a2', 'b2',
1266
 
                                 sequencematcher=psm)))
 
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)))
1267
1336
 
1268
1337
 
1269
1338
class TestPatienceDiffLibFiles_c(TestPatienceDiffLibFiles):
1270
1339
 
1271
 
    _test_needs_features = [compiled_patiencediff_feature]
 
1340
    _test_needs_features = [features.compiled_patiencediff_feature]
1272
1341
 
1273
1342
    def setUp(self):
1274
1343
        super(TestPatienceDiffLibFiles_c, self).setUp()
1280
1349
class TestUsingCompiledIfAvailable(tests.TestCase):
1281
1350
 
1282
1351
    def test_PatienceSequenceMatcher(self):
1283
 
        if compiled_patiencediff_feature.available():
 
1352
        if features.compiled_patiencediff_feature.available():
1284
1353
            from bzrlib._patiencediff_c import PatienceSequenceMatcher_c
1285
1354
            self.assertIs(PatienceSequenceMatcher_c,
1286
1355
                          patiencediff.PatienceSequenceMatcher)
1290
1359
                          patiencediff.PatienceSequenceMatcher)
1291
1360
 
1292
1361
    def test_unique_lcs(self):
1293
 
        if compiled_patiencediff_feature.available():
 
1362
        if features.compiled_patiencediff_feature.available():
1294
1363
            from bzrlib._patiencediff_c import unique_lcs_c
1295
1364
            self.assertIs(unique_lcs_c,
1296
1365
                          patiencediff.unique_lcs)
1300
1369
                          patiencediff.unique_lcs)
1301
1370
 
1302
1371
    def test_recurse_matches(self):
1303
 
        if compiled_patiencediff_feature.available():
 
1372
        if features.compiled_patiencediff_feature.available():
1304
1373
            from bzrlib._patiencediff_c import recurse_matches_c
1305
1374
            self.assertIs(recurse_matches_c,
1306
1375
                          patiencediff.recurse_matches)
1346
1415
        diff_obj._execute('old', 'new')
1347
1416
        self.assertEqual(output.getvalue().rstrip(), 'old new')
1348
1417
 
1349
 
    def test_excute_missing(self):
 
1418
    def test_execute_missing(self):
1350
1419
        diff_obj = diff.DiffFromTool(['a-tool-which-is-unlikely-to-exist'],
1351
1420
                                     None, None, None)
1352
1421
        self.addCleanup(diff_obj.finish)
1356
1425
                         ' on this machine', str(e))
1357
1426
 
1358
1427
    def test_prepare_files_creates_paths_readable_by_windows_tool(self):
1359
 
        self.requireFeature(AttribFeature)
 
1428
        self.requireFeature(features.AttribFeature)
1360
1429
        output = StringIO()
1361
1430
        tree = self.make_branch_and_tree('tree')
1362
1431
        self.build_tree_contents([('tree/file', 'content')])
1426
1495
    def test_encodable_filename(self):
1427
1496
        # Just checks file path for external diff tool.
1428
1497
        # We cannot change CPython's internal encoding used by os.exec*.
1429
 
        import sys
1430
1498
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1431
1499
                                    None, None, None)
1432
1500
        for _, scenario in EncodingAdapter.encoding_scenarios:
1433
1501
            encoding = scenario['encoding']
1434
 
            dirname  = scenario['info']['directory']
 
1502
            dirname = scenario['info']['directory']
1435
1503
            filename = scenario['info']['filename']
1436
1504
 
1437
1505
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1438
1506
            relpath = dirname + u'/' + filename
1439
1507
            fullpath = diffobj._safe_filename('safe', relpath)
1440
 
            self.assertEqual(
1441
 
                    fullpath,
1442
 
                    fullpath.encode(encoding).decode(encoding)
1443
 
                    )
1444
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1508
            self.assertEqual(fullpath,
 
1509
                             fullpath.encode(encoding).decode(encoding))
 
1510
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
1445
1511
 
1446
1512
    def test_unencodable_filename(self):
1447
 
        import sys
1448
1513
        diffobj = diff.DiffFromTool(['dummy', '@old_path', '@new_path'],
1449
1514
                                    None, None, None)
1450
1515
        for _, scenario in EncodingAdapter.encoding_scenarios:
1451
1516
            encoding = scenario['encoding']
1452
 
            dirname  = scenario['info']['directory']
 
1517
            dirname = scenario['info']['directory']
1453
1518
            filename = scenario['info']['filename']
1454
1519
 
1455
1520
            if encoding == 'iso-8859-1':
1460
1525
            self.overrideAttr(diffobj, '_fenc', lambda: encoding)
1461
1526
            relpath = dirname + u'/' + filename
1462
1527
            fullpath = diffobj._safe_filename('safe', relpath)
1463
 
            self.assertEqual(
1464
 
                    fullpath,
1465
 
                    fullpath.encode(encoding).decode(encoding)
1466
 
                    )
1467
 
            self.assert_(fullpath.startswith(diffobj._root + '/safe'))
 
1528
            self.assertEqual(fullpath,
 
1529
                             fullpath.encode(encoding).decode(encoding))
 
1530
            self.assertTrue(fullpath.startswith(diffobj._root + '/safe'))
1468
1531
 
1469
1532
 
1470
1533
class TestGetTreesAndBranchesToDiffLocked(tests.TestCaseWithTransport):
1471
1534
 
1472
1535
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1473
 
        """Call get_trees_and_branches_to_diff_locked.  Overridden by
1474
 
        TestGetTreesAndBranchesToDiff.
1475
 
        """
 
1536
        """Call get_trees_and_branches_to_diff_locked."""
1476
1537
        return diff.get_trees_and_branches_to_diff_locked(
1477
1538
            path_list, revision_specs, old_url, new_url, self.addCleanup)
1478
1539
 
1515
1576
        self.assertEqual(tree.branch.base, new_branch.base)
1516
1577
        self.assertIs(None, specific_files)
1517
1578
        self.assertEqual(tree.basedir, extra_trees[0].basedir)
1518
 
 
1519
 
 
1520
 
class TestGetTreesAndBranchesToDiff(TestGetTreesAndBranchesToDiffLocked):
1521
 
    """Apply the tests for get_trees_and_branches_to_diff_locked to the
1522
 
    deprecated get_trees_and_branches_to_diff function.
1523
 
    """
1524
 
 
1525
 
    def call_gtabtd(self, path_list, revision_specs, old_url, new_url):
1526
 
        return self.applyDeprecated(
1527
 
            deprecated_in((2, 2, 0)), diff.get_trees_and_branches_to_diff,
1528
 
            path_list, revision_specs, old_url, new_url)