/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/tests/test_osutils_encodings.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-07-04 12:50:55 UTC
  • mfrom: (7027.2.8 git-fixes)
  • Revision ID: breezy.the.bot@gmail.com-20180704125055-8nni25pn2439p48v
Fix eol handling in knits on Python 3, port fastimport plugin to Python 3.

Merged from https://code.launchpad.net/~jelmer/brz/fastimport-fixes/+merge/348924

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_osutils_encodings.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 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
18
18
 
19
19
import codecs
20
20
import locale
21
 
import os
22
21
import sys
23
22
 
24
 
from bzrlib import (
25
 
    errors,
 
23
from .. import (
26
24
    osutils,
27
25
    )
28
 
from bzrlib.tests import (
29
 
        StringIOWrapper,
30
 
        TestCase,
31
 
        )
 
26
from . import (
 
27
    TestCase,
 
28
    )
 
29
from .ui_testing import BytesIOWithEncoding
32
30
 
33
31
 
34
32
class FakeCodec(object):
74
72
    """Test the auto-detection of proper terminal encoding."""
75
73
 
76
74
    def setUp(self):
77
 
        TestCase.setUp(self)
 
75
        super(TestTerminalEncoding, self).setUp()
78
76
        self.overrideAttr(sys, 'stdin')
79
77
        self.overrideAttr(sys, 'stdout')
80
78
        self.overrideAttr(sys, 'stderr')
86
84
                             stdin_encoding,
87
85
                             user_encoding='user_encoding',
88
86
                             enable_fake_encodings=True):
89
 
        sys.stdout = StringIOWrapper()
 
87
        sys.stdout = BytesIOWithEncoding()
90
88
        sys.stdout.encoding = stdout_encoding
91
 
        sys.stderr = StringIOWrapper()
 
89
        sys.stderr = BytesIOWithEncoding()
92
90
        sys.stderr.encoding = stderr_encoding
93
 
        sys.stdin = StringIOWrapper()
 
91
        sys.stdin = BytesIOWithEncoding()
94
92
        sys.stdin.encoding = stdin_encoding
95
93
        osutils._cached_user_encoding = user_encoding
96
94
        if enable_fake_encodings:
114
112
        # and in the worst case, use osutils.get_user_encoding()
115
113
        self.assertEqual('user_encoding', osutils.get_terminal_encoding())
116
114
 
 
115
    def test_get_terminal_encoding_silent(self):
 
116
        self.make_wrapped_streams('stdout_encoding',
 
117
                                  'stderr_encoding',
 
118
                                  'stdin_encoding')
 
119
        # Calling get_terminal_encoding should not mutter when silent=True is
 
120
        # passed.
 
121
        log = self.get_log()
 
122
        osutils.get_terminal_encoding()
 
123
        self.assertEqual(log, self.get_log())
 
124
 
 
125
    def test_get_terminal_encoding_trace(self):
 
126
        self.make_wrapped_streams('stdout_encoding',
 
127
                                  'stderr_encoding',
 
128
                                  'stdin_encoding')
 
129
        # Calling get_terminal_encoding should not mutter when silent=True is
 
130
        # passed.
 
131
        log = self.get_log()
 
132
        osutils.get_terminal_encoding(trace=True)
 
133
        self.assertNotEqual(log, self.get_log())
 
134
 
117
135
    def test_terminal_cp0(self):
118
136
        # test cp0 encoding (Windows returns cp0 when there is no encoding)
119
137
        self.make_wrapped_streams('cp0',
126
144
        self.assertEqual('latin-1', osutils.get_terminal_encoding())
127
145
 
128
146
        # check stderr
129
 
        self.assertEquals('', sys.stderr.getvalue())
 
147
        self.assertEqual('', sys.stderr.getvalue())
130
148
 
131
149
    def test_terminal_cp_unknown(self):
132
150
        # test against really unknown encoding
140
158
        self.assertEqual('latin-1', osutils.get_terminal_encoding())
141
159
 
142
160
        # check stderr
143
 
        self.assertEquals('bzr: warning: unknown terminal encoding cp-unknown.\n'
 
161
        self.assertEqual('brz: warning: unknown terminal encoding cp-unknown.\n'
144
162
                          '  Using encoding latin-1 instead.\n',
145
163
                          sys.stderr.getvalue())
146
164
 
149
167
    """Test detection of default user encoding."""
150
168
 
151
169
    def setUp(self):
152
 
        TestCase.setUp(self)
153
 
        self.overrideAttr(locale, 'getpreferredencoding')
154
 
        self.addCleanup(osutils.set_or_unset_env,
155
 
                        'LANG', os.environ.get('LANG'))
156
 
        self.overrideAttr(sys, 'stderr', StringIOWrapper())
 
170
        super(TestUserEncoding, self).setUp()
 
171
        self.overrideAttr(osutils, '_cached_user_encoding', None)
 
172
        self.overrideAttr(locale, 'getpreferredencoding', self.get_encoding)
 
173
        self.overrideAttr(locale, 'CODESET', None)
 
174
        self.overrideAttr(sys, 'stderr', BytesIOWithEncoding())
 
175
 
 
176
    def get_encoding(self, do_setlocale=True):
 
177
        return self._encoding
157
178
 
158
179
    def test_get_user_encoding(self):
159
 
        def f():
160
 
            return 'user_encoding'
161
 
 
162
 
        locale.getpreferredencoding = f
 
180
        self._encoding = 'user_encoding'
163
181
        fake_codec.add('user_encoding')
164
 
        self.assertEquals('user_encoding', osutils.get_user_encoding(use_cache=False))
165
 
        self.assertEquals('', sys.stderr.getvalue())
 
182
        self.assertEqual('iso8859-1', # fake_codec maps to latin-1
 
183
                          osutils.get_user_encoding())
 
184
        self.assertEqual('', sys.stderr.getvalue())
166
185
 
167
186
    def test_user_cp0(self):
168
 
        def f():
169
 
            return 'cp0'
170
 
 
171
 
        locale.getpreferredencoding = f
172
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
173
 
        self.assertEquals('', sys.stderr.getvalue())
 
187
        self._encoding = 'cp0'
 
188
        self.assertEqual('ascii', osutils.get_user_encoding())
 
189
        self.assertEqual('', sys.stderr.getvalue())
174
190
 
175
191
    def test_user_cp_unknown(self):
176
 
        def f():
177
 
            return 'cp-unknown'
178
 
 
179
 
        locale.getpreferredencoding = f
180
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
181
 
        self.assertEquals('bzr: warning: unknown encoding cp-unknown.'
 
192
        self._encoding = 'cp-unknown'
 
193
        self.assertEqual('ascii', osutils.get_user_encoding())
 
194
        self.assertEqual('brz: warning: unknown encoding cp-unknown.'
182
195
                          ' Continuing with ascii encoding.\n',
183
196
                          sys.stderr.getvalue())
184
197
 
185
198
    def test_user_empty(self):
186
199
        """Running bzr from a vim script gives '' for a preferred locale"""
187
 
        def f():
188
 
            return ''
189
 
 
190
 
        locale.getpreferredencoding = f
191
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
192
 
        self.assertEquals('', sys.stderr.getvalue())
193
 
 
194
 
    def test_user_locale_error(self):
195
 
        def f():
196
 
            raise locale.Error, 'unsupported locale'
197
 
 
198
 
        locale.getpreferredencoding = f
199
 
        os.environ['LANG'] = 'BOGUS'
200
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
201
 
        self.assertEquals('bzr: warning: unsupported locale\n'
202
 
                          '  Could not determine what text encoding to use.\n'
203
 
                          '  This error usually means your Python interpreter\n'
204
 
                          '  doesn\'t support the locale set by $LANG (BOGUS)\n'
205
 
                          '  Continuing with ascii encoding.\n',
206
 
                          sys.stderr.getvalue())
 
200
        self._encoding = ''
 
201
        self.assertEqual('ascii', osutils.get_user_encoding())
 
202
        self.assertEqual('', sys.stderr.getvalue())