/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: 2020-08-23 01:15:41 UTC
  • mfrom: (7520.1.4 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200823011541-nv0oh7nzaganx2qy
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/389690

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 (
 
30
    BytesIOWithEncoding,
 
31
    StringIOWithEncoding,
 
32
    )
32
33
 
33
34
 
34
35
class FakeCodec(object):
74
75
    """Test the auto-detection of proper terminal encoding."""
75
76
 
76
77
    def setUp(self):
77
 
        TestCase.setUp(self)
 
78
        super(TestTerminalEncoding, self).setUp()
78
79
        self.overrideAttr(sys, 'stdin')
79
80
        self.overrideAttr(sys, 'stdout')
80
81
        self.overrideAttr(sys, 'stderr')
86
87
                             stdin_encoding,
87
88
                             user_encoding='user_encoding',
88
89
                             enable_fake_encodings=True):
89
 
        sys.stdout = StringIOWrapper()
 
90
        sys.stdout = StringIOWithEncoding()
90
91
        sys.stdout.encoding = stdout_encoding
91
 
        sys.stderr = StringIOWrapper()
 
92
        sys.stderr = StringIOWithEncoding()
92
93
        sys.stderr.encoding = stderr_encoding
93
 
        sys.stdin = StringIOWrapper()
 
94
        sys.stdin = StringIOWithEncoding()
94
95
        sys.stdin.encoding = stdin_encoding
95
96
        osutils._cached_user_encoding = user_encoding
96
97
        if enable_fake_encodings:
114
115
        # and in the worst case, use osutils.get_user_encoding()
115
116
        self.assertEqual('user_encoding', osutils.get_terminal_encoding())
116
117
 
 
118
    def test_get_terminal_encoding_silent(self):
 
119
        self.make_wrapped_streams('stdout_encoding',
 
120
                                  'stderr_encoding',
 
121
                                  'stdin_encoding')
 
122
        # Calling get_terminal_encoding should not mutter when silent=True is
 
123
        # passed.
 
124
        log = self.get_log()
 
125
        osutils.get_terminal_encoding()
 
126
        self.assertEqual(log, self.get_log())
 
127
 
 
128
    def test_get_terminal_encoding_trace(self):
 
129
        self.make_wrapped_streams('stdout_encoding',
 
130
                                  'stderr_encoding',
 
131
                                  'stdin_encoding')
 
132
        # Calling get_terminal_encoding should not mutter when silent=True is
 
133
        # passed.
 
134
        log = self.get_log()
 
135
        osutils.get_terminal_encoding(trace=True)
 
136
        self.assertNotEqual(log, self.get_log())
 
137
 
117
138
    def test_terminal_cp0(self):
118
139
        # test cp0 encoding (Windows returns cp0 when there is no encoding)
119
140
        self.make_wrapped_streams('cp0',
126
147
        self.assertEqual('latin-1', osutils.get_terminal_encoding())
127
148
 
128
149
        # check stderr
129
 
        self.assertEquals('', sys.stderr.getvalue())
 
150
        self.assertEqual('', sys.stderr.getvalue())
130
151
 
131
152
    def test_terminal_cp_unknown(self):
132
153
        # test against really unknown encoding
140
161
        self.assertEqual('latin-1', osutils.get_terminal_encoding())
141
162
 
142
163
        # check stderr
143
 
        self.assertEquals('bzr: warning: unknown terminal encoding cp-unknown.\n'
144
 
                          '  Using encoding latin-1 instead.\n',
145
 
                          sys.stderr.getvalue())
 
164
        self.assertEqual('brz: warning: unknown terminal encoding cp-unknown.\n'
 
165
                         '  Using encoding latin-1 instead.\n',
 
166
                         sys.stderr.getvalue())
146
167
 
147
168
 
148
169
class TestUserEncoding(TestCase):
149
170
    """Test detection of default user encoding."""
150
171
 
151
172
    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())
 
173
        super(TestUserEncoding, self).setUp()
 
174
        self.overrideAttr(osutils, '_cached_user_encoding', None)
 
175
        self.overrideAttr(locale, 'getpreferredencoding', self.get_encoding)
 
176
        self.overrideAttr(locale, 'CODESET', None)
 
177
        self.overrideAttr(sys, 'stderr', StringIOWithEncoding())
 
178
 
 
179
    def get_encoding(self, do_setlocale=True):
 
180
        return self._encoding
157
181
 
158
182
    def test_get_user_encoding(self):
159
 
        def f():
160
 
            return 'user_encoding'
161
 
 
162
 
        locale.getpreferredencoding = f
 
183
        self._encoding = 'user_encoding'
163
184
        fake_codec.add('user_encoding')
164
 
        self.assertEquals('user_encoding', osutils.get_user_encoding(use_cache=False))
165
 
        self.assertEquals('', sys.stderr.getvalue())
 
185
        self.assertEqual('iso8859-1',  # fake_codec maps to latin-1
 
186
                         osutils.get_user_encoding())
 
187
        self.assertEqual('', sys.stderr.getvalue())
166
188
 
167
189
    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())
 
190
        self._encoding = 'cp0'
 
191
        self.assertEqual('ascii', osutils.get_user_encoding())
 
192
        self.assertEqual('', sys.stderr.getvalue())
174
193
 
175
194
    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.'
182
 
                          ' Continuing with ascii encoding.\n',
183
 
                          sys.stderr.getvalue())
 
195
        self._encoding = 'cp-unknown'
 
196
        self.assertEqual('ascii', osutils.get_user_encoding())
 
197
        self.assertEqual('brz: warning: unknown encoding cp-unknown.'
 
198
                         ' Continuing with ascii encoding.\n',
 
199
                         sys.stderr.getvalue())
184
200
 
185
201
    def test_user_empty(self):
186
202
        """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())
 
203
        self._encoding = ''
 
204
        self.assertEqual('ascii', osutils.get_user_encoding())
 
205
        self.assertEqual('', sys.stderr.getvalue())