← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils_encodings.py

(vila) Fix test failures blocking package builds. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils_encodings.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2011 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
23
from bzrlib import (
25
 
    errors,
26
24
    osutils,
27
25
    )
28
26
from bzrlib.tests import (
74
72
    """Test the auto-detection of proper terminal encoding."""
75
73
 
76
74
    def setUp(self):
77
 
        TestCase.setUp(self)
78
 
        self._stdout = sys.stdout
79
 
        self._stderr = sys.stderr
80
 
        self._stdin = sys.stdin
81
 
        self._user_encoding = osutils._cached_user_encoding
82
 
 
83
 
        self.addCleanup(self._reset)
 
75
        super(TestTerminalEncoding, self).setUp()
 
76
        self.overrideAttr(sys, 'stdin')
 
77
        self.overrideAttr(sys, 'stdout')
 
78
        self.overrideAttr(sys, 'stderr')
 
79
        self.overrideAttr(osutils, '_cached_user_encoding')
84
80
 
85
81
    def make_wrapped_streams(self,
86
82
                             stdout_encoding,
100
96
            fake_codec.add(stderr_encoding)
101
97
            fake_codec.add(stdin_encoding)
102
98
 
103
 
    def _reset(self):
104
 
        sys.stdout = self._stdout
105
 
        sys.stderr = self._stderr
106
 
        sys.stdin = self._stdin
107
 
        osutils._cached_user_encoding = self._user_encoding
108
 
 
109
99
    def test_get_terminal_encoding(self):
110
100
        self.make_wrapped_streams('stdout_encoding',
111
101
                                  'stderr_encoding',
122
112
        # and in the worst case, use osutils.get_user_encoding()
123
113
        self.assertEqual('user_encoding', osutils.get_terminal_encoding())
124
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
 
125
135
    def test_terminal_cp0(self):
126
136
        # test cp0 encoding (Windows returns cp0 when there is no encoding)
127
137
        self.make_wrapped_streams('cp0',
157
167
    """Test detection of default user encoding."""
158
168
 
159
169
    def setUp(self):
160
 
        TestCase.setUp(self)
161
 
        self._stderr = sys.stderr
162
 
        self._getpreferredencoding = locale.getpreferredencoding
163
 
        self.addCleanup(self._reset)
164
 
        sys.stderr = StringIOWrapper()
165
 
        # save $LANG
166
 
        self._LANG = os.environ.get('LANG')
 
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', StringIOWrapper())
167
175
 
168
 
    def _reset(self):
169
 
        locale.getpreferredencoding = self._getpreferredencoding
170
 
        sys.stderr = self._stderr
171
 
        # restore $LANG
172
 
        osutils.set_or_unset_env('LANG', self._LANG)
 
176
    def get_encoding(self, do_setlocale=True):
 
177
        return self._encoding
173
178
 
174
179
    def test_get_user_encoding(self):
175
 
        def f():
176
 
            return 'user_encoding'
177
 
 
178
 
        locale.getpreferredencoding = f
 
180
        self._encoding = 'user_encoding'
179
181
        fake_codec.add('user_encoding')
180
 
        self.assertEquals('user_encoding', osutils.get_user_encoding(use_cache=False))
 
182
        self.assertEquals('iso8859-1', # fake_codec maps to latin-1
 
183
                          osutils.get_user_encoding())
181
184
        self.assertEquals('', sys.stderr.getvalue())
182
185
 
183
186
    def test_user_cp0(self):
184
 
        def f():
185
 
            return 'cp0'
186
 
 
187
 
        locale.getpreferredencoding = f
188
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
 
187
        self._encoding = 'cp0'
 
188
        self.assertEquals('ascii', osutils.get_user_encoding())
189
189
        self.assertEquals('', sys.stderr.getvalue())
190
190
 
191
191
    def test_user_cp_unknown(self):
192
 
        def f():
193
 
            return 'cp-unknown'
194
 
 
195
 
        locale.getpreferredencoding = f
196
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
 
192
        self._encoding = 'cp-unknown'
 
193
        self.assertEquals('ascii', osutils.get_user_encoding())
197
194
        self.assertEquals('bzr: warning: unknown encoding cp-unknown.'
198
195
                          ' Continuing with ascii encoding.\n',
199
196
                          sys.stderr.getvalue())
200
197
 
201
198
    def test_user_empty(self):
202
199
        """Running bzr from a vim script gives '' for a preferred locale"""
203
 
        def f():
204
 
            return ''
205
 
 
206
 
        locale.getpreferredencoding = f
207
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
 
200
        self._encoding = ''
 
201
        self.assertEquals('ascii', osutils.get_user_encoding())
208
202
        self.assertEquals('', sys.stderr.getvalue())
209
 
 
210
 
    def test_user_locale_error(self):
211
 
        def f():
212
 
            raise locale.Error, 'unsupported locale'
213
 
 
214
 
        locale.getpreferredencoding = f
215
 
        os.environ['LANG'] = 'BOGUS'
216
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
217
 
        self.assertEquals('bzr: warning: unsupported locale\n'
218
 
                          '  Could not determine what text encoding to use.\n'
219
 
                          '  This error usually means your Python interpreter\n'
220
 
                          '  doesn\'t support the locale set by $LANG (BOGUS)\n'
221
 
                          '  Continuing with ascii encoding.\n',
222
 
                          sys.stderr.getvalue())