← 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

Merge bzr.dev and tree-file-ids-as-tuples.

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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the osutils wrapper."""
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 (
29
27
        StringIOWrapper,
30
 
        TestCase, 
 
28
        TestCase,
31
29
        )
32
30
 
33
31
 
34
32
class FakeCodec(object):
35
33
    """Special class that helps testing over several non-existed encodings.
36
 
    
 
34
 
37
35
    Clients can add new encoding names, but because of how codecs is
38
36
    implemented they cannot be removed. Be careful with naming to avoid
39
37
    collisions between tests.
51
49
            self._registered = True
52
50
        if encoding_name is not None:
53
51
            self._enabled_encodings.add(encoding_name)
54
 
        
 
52
 
55
53
    def __call__(self, encoding_name):
56
54
        """Called indirectly by codecs module during lookup"""
57
55
        if encoding_name in self._enabled_encodings:
62
60
 
63
61
 
64
62
class TestFakeCodec(TestCase):
65
 
    
 
63
 
66
64
    def test_fake_codec(self):
67
65
        self.assertRaises(LookupError, codecs.lookup, 'fake')
68
66
 
74
72
    """Test the auto-detection of proper terminal encoding."""
75
73
 
76
74
    def setUp(self):
77
 
        self._stdout = sys.stdout
78
 
        self._stderr = sys.stderr
79
 
        self._stdin = sys.stdin
80
 
        self._user_encoding = osutils._cached_user_encoding
81
 
 
82
 
        self.addCleanup(self._reset)
83
 
 
84
 
    def make_wrapped_streams(self, 
 
75
        TestCase.setUp(self)
 
76
        self.overrideAttr(sys, 'stdin')
 
77
        self.overrideAttr(sys, 'stdout')
 
78
        self.overrideAttr(sys, 'stderr')
 
79
        self.overrideAttr(osutils, '_cached_user_encoding')
 
80
 
 
81
    def make_wrapped_streams(self,
85
82
                             stdout_encoding,
86
83
                             stderr_encoding,
87
84
                             stdin_encoding,
99
96
            fake_codec.add(stderr_encoding)
100
97
            fake_codec.add(stdin_encoding)
101
98
 
102
 
    def _reset(self):
103
 
        sys.stdout = self._stdout
104
 
        sys.stderr = self._stderr
105
 
        sys.stdin = self._stdin
106
 
        osutils._cached_user_encoding = self._user_encoding
107
 
 
108
99
    def test_get_terminal_encoding(self):
109
100
        self.make_wrapped_streams('stdout_encoding',
110
101
                                  'stderr_encoding',
121
112
        # and in the worst case, use osutils.get_user_encoding()
122
113
        self.assertEqual('user_encoding', osutils.get_terminal_encoding())
123
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
 
124
135
    def test_terminal_cp0(self):
125
136
        # test cp0 encoding (Windows returns cp0 when there is no encoding)
126
137
        self.make_wrapped_streams('cp0',
143
154
                                  'cp-unknown',
144
155
                                  user_encoding='latin-1',
145
156
                                  enable_fake_encodings=False)
146
 
        
 
157
 
147
158
        self.assertEqual('latin-1', osutils.get_terminal_encoding())
148
159
 
149
160
        # check stderr
150
161
        self.assertEquals('bzr: warning: unknown terminal encoding cp-unknown.\n'
151
 
                          '  Using encoding latin-1 instead.\n', 
 
162
                          '  Using encoding latin-1 instead.\n',
152
163
                          sys.stderr.getvalue())
153
164
 
154
165
 
155
166
class TestUserEncoding(TestCase):
156
167
    """Test detection of default user encoding."""
157
 
    
 
168
 
158
169
    def setUp(self):
159
 
        self._stderr = sys.stderr
160
 
        self._getpreferredencoding = locale.getpreferredencoding
161
 
        self.addCleanup(self._reset)
162
 
        sys.stderr = StringIOWrapper()
163
 
        # save $LANG
164
 
        self._LANG = os.environ.get('LANG')
 
170
        TestCase.setUp(self)
 
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())
165
175
 
166
 
    def _reset(self):
167
 
        locale.getpreferredencoding = self._getpreferredencoding
168
 
        sys.stderr = self._stderr
169
 
        # restore $LANG
170
 
        osutils.set_or_unset_env('LANG', self._LANG)
 
176
    def get_encoding(self, do_setlocale=True):
 
177
        return self._encoding
171
178
 
172
179
    def test_get_user_encoding(self):
173
 
        def f():
174
 
            return 'user_encoding'
175
 
 
176
 
        locale.getpreferredencoding = f
 
180
        self._encoding = 'user_encoding'
177
181
        fake_codec.add('user_encoding')
178
 
        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())
179
184
        self.assertEquals('', sys.stderr.getvalue())
180
185
 
181
186
    def test_user_cp0(self):
182
 
        def f():
183
 
            return 'cp0'
184
 
 
185
 
        locale.getpreferredencoding = f
186
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
 
187
        self._encoding = 'cp0'
 
188
        self.assertEquals('ascii', osutils.get_user_encoding())
187
189
        self.assertEquals('', sys.stderr.getvalue())
188
190
 
189
191
    def test_user_cp_unknown(self):
190
 
        def f():
191
 
            return 'cp-unknown'
192
 
 
193
 
        locale.getpreferredencoding = f
194
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
 
192
        self._encoding = 'cp-unknown'
 
193
        self.assertEquals('ascii', osutils.get_user_encoding())
195
194
        self.assertEquals('bzr: warning: unknown encoding cp-unknown.'
196
195
                          ' Continuing with ascii encoding.\n',
197
196
                          sys.stderr.getvalue())
198
197
 
199
198
    def test_user_empty(self):
200
199
        """Running bzr from a vim script gives '' for a preferred locale"""
201
 
        def f():
202
 
            return ''
203
 
 
204
 
        locale.getpreferredencoding = f
205
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
 
200
        self._encoding = ''
 
201
        self.assertEquals('ascii', osutils.get_user_encoding())
206
202
        self.assertEquals('', sys.stderr.getvalue())
207
 
 
208
 
    def test_user_locale_error(self):
209
 
        def f():
210
 
            raise locale.Error, 'unsupported locale'
211
 
 
212
 
        locale.getpreferredencoding = f
213
 
        os.environ['LANG'] = 'BOGUS'
214
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
215
 
        self.assertEquals('bzr: warning: unsupported locale\n'
216
 
                          '  Could not determine what text encoding to use.\n'
217
 
                          '  This error usually means your Python interpreter\n'
218
 
                          '  doesn\'t support the locale set by $LANG (BOGUS)\n'
219
 
                          '  Continuing with ascii encoding.\n',
220
 
                          sys.stderr.getvalue())