← 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

  • Committer: Patch Queue Manager
  • Date: 2011-09-22 14:12:18 UTC
  • mfrom: (6155.3.1 jam)
  • Revision ID: pqm@pqm.ubuntu.com-20110922141218-86s4uu6nqvourw4f
(jameinel) Cleanup comments bzrlib/smart/__init__.py (John A Meinel)

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
 
import bzrlib
25
23
from bzrlib import (
26
 
    errors,
27
24
    osutils,
28
25
    )
29
26
from bzrlib.tests import (
30
27
        StringIOWrapper,
31
 
        TestCase, 
32
 
        TestSkipped,
 
28
        TestCase,
33
29
        )
34
30
 
35
31
 
36
32
class FakeCodec(object):
37
33
    """Special class that helps testing over several non-existed encodings.
38
 
    
 
34
 
39
35
    Clients can add new encoding names, but because of how codecs is
40
36
    implemented they cannot be removed. Be careful with naming to avoid
41
37
    collisions between tests.
53
49
            self._registered = True
54
50
        if encoding_name is not None:
55
51
            self._enabled_encodings.add(encoding_name)
56
 
        
 
52
 
57
53
    def __call__(self, encoding_name):
58
54
        """Called indirectly by codecs module during lookup"""
59
55
        if encoding_name in self._enabled_encodings:
64
60
 
65
61
 
66
62
class TestFakeCodec(TestCase):
67
 
    
 
63
 
68
64
    def test_fake_codec(self):
69
65
        self.assertRaises(LookupError, codecs.lookup, 'fake')
70
66
 
76
72
    """Test the auto-detection of proper terminal encoding."""
77
73
 
78
74
    def setUp(self):
79
 
        self._stdout = sys.stdout
80
 
        self._stderr = sys.stderr
81
 
        self._stdin = sys.stdin
82
 
        self._user_encoding = bzrlib.user_encoding
83
 
 
84
 
        self.addCleanup(self._reset)
85
 
 
86
 
    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,
87
82
                             stdout_encoding,
88
83
                             stderr_encoding,
89
84
                             stdin_encoding,
95
90
        sys.stderr.encoding = stderr_encoding
96
91
        sys.stdin = StringIOWrapper()
97
92
        sys.stdin.encoding = stdin_encoding
98
 
        bzrlib.user_encoding = user_encoding
 
93
        osutils._cached_user_encoding = user_encoding
99
94
        if enable_fake_encodings:
100
95
            fake_codec.add(stdout_encoding)
101
96
            fake_codec.add(stderr_encoding)
102
97
            fake_codec.add(stdin_encoding)
103
98
 
104
 
    def _reset(self):
105
 
        sys.stdout = self._stdout
106
 
        sys.stderr = self._stderr
107
 
        sys.stdin = self._stdin
108
 
        bzrlib.user_encoding = self._user_encoding
109
 
 
110
99
    def test_get_terminal_encoding(self):
111
100
        self.make_wrapped_streams('stdout_encoding',
112
101
                                  'stderr_encoding',
120
109
        self.assertEqual('stdin_encoding', osutils.get_terminal_encoding())
121
110
 
122
111
        sys.stdin.encoding = None
123
 
        # and in the worst case, use bzrlib.user_encoding
 
112
        # and in the worst case, use osutils.get_user_encoding()
124
113
        self.assertEqual('user_encoding', osutils.get_terminal_encoding())
125
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
 
126
135
    def test_terminal_cp0(self):
127
136
        # test cp0 encoding (Windows returns cp0 when there is no encoding)
128
137
        self.make_wrapped_streams('cp0',
145
154
                                  'cp-unknown',
146
155
                                  user_encoding='latin-1',
147
156
                                  enable_fake_encodings=False)
148
 
        
 
157
 
149
158
        self.assertEqual('latin-1', osutils.get_terminal_encoding())
150
159
 
151
160
        # check stderr
152
161
        self.assertEquals('bzr: warning: unknown terminal encoding cp-unknown.\n'
153
 
                          '  Using encoding latin-1 instead.\n', 
 
162
                          '  Using encoding latin-1 instead.\n',
154
163
                          sys.stderr.getvalue())
155
164
 
156
165
 
157
166
class TestUserEncoding(TestCase):
158
167
    """Test detection of default user encoding."""
159
 
    
 
168
 
160
169
    def 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')
167
 
 
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)
 
170
        TestCase.setUp(self)
 
171
        self.overrideAttr(locale, 'getpreferredencoding')
 
172
        self.overrideAttr(sys, 'stderr', StringIOWrapper())
173
173
 
174
174
    def test_get_user_encoding(self):
175
175
        def f():
177
177
 
178
178
        locale.getpreferredencoding = f
179
179
        fake_codec.add('user_encoding')
180
 
        self.assertEquals('user_encoding', osutils.get_user_encoding(use_cache=False))
 
180
        self.assertEquals('user_encoding',
 
181
                          osutils.get_user_encoding(use_cache=False))
181
182
        self.assertEquals('', sys.stderr.getvalue())
182
183
 
183
184
    def test_user_cp0(self):
198
199
                          ' Continuing with ascii encoding.\n',
199
200
                          sys.stderr.getvalue())
200
201
 
 
202
    def test_user_empty(self):
 
203
        """Running bzr from a vim script gives '' for a preferred locale"""
 
204
        def f():
 
205
            return ''
 
206
 
 
207
        locale.getpreferredencoding = f
 
208
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
 
209
        self.assertEquals('', sys.stderr.getvalue())
 
210
 
201
211
    def test_user_locale_error(self):
202
212
        def f():
203
213
            raise locale.Error, 'unsupported locale'
204
214
 
205
215
        locale.getpreferredencoding = f
206
 
        os.environ['LANG'] = 'BOGUS'
 
216
        self.overrideEnv('LANG', 'BOGUS')
207
217
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
208
218
        self.assertEquals('bzr: warning: unsupported locale\n'
209
219
                          '  Could not determine what text encoding to use.\n'