← 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: Martin Albisetti
  • Date: 2008-05-06 00:21:18 UTC
  • mto: (3431.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 3432.
  • Revision ID: argentina@gmail.com-20080506002118-7w9ywklw4khddf3g
Added spanish index

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils_encodings.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for the osutils wrapper."""
18
18
 
21
21
import os
22
22
import sys
23
23
 
 
24
import bzrlib
24
25
from bzrlib import (
25
26
    errors,
26
27
    osutils,
27
28
    )
28
29
from bzrlib.tests import (
29
30
        StringIOWrapper,
30
 
        TestCase,
 
31
        TestCase, 
31
32
        )
32
33
 
33
34
 
34
35
class FakeCodec(object):
35
36
    """Special class that helps testing over several non-existed encodings.
36
 
 
 
37
    
37
38
    Clients can add new encoding names, but because of how codecs is
38
39
    implemented they cannot be removed. Be careful with naming to avoid
39
40
    collisions between tests.
51
52
            self._registered = True
52
53
        if encoding_name is not None:
53
54
            self._enabled_encodings.add(encoding_name)
54
 
 
 
55
        
55
56
    def __call__(self, encoding_name):
56
57
        """Called indirectly by codecs module during lookup"""
57
58
        if encoding_name in self._enabled_encodings:
62
63
 
63
64
 
64
65
class TestFakeCodec(TestCase):
65
 
 
 
66
    
66
67
    def test_fake_codec(self):
67
68
        self.assertRaises(LookupError, codecs.lookup, 'fake')
68
69
 
74
75
    """Test the auto-detection of proper terminal encoding."""
75
76
 
76
77
    def setUp(self):
77
 
        TestCase.setUp(self)
78
 
        self.overrideAttr(sys, 'stdin')
79
 
        self.overrideAttr(sys, 'stdout')
80
 
        self.overrideAttr(sys, 'stderr')
81
 
        self.overrideAttr(osutils, '_cached_user_encoding')
82
 
 
83
 
    def make_wrapped_streams(self,
 
78
        self._stdout = sys.stdout
 
79
        self._stderr = sys.stderr
 
80
        self._stdin = sys.stdin
 
81
        self._user_encoding = bzrlib.user_encoding
 
82
 
 
83
        self.addCleanup(self._reset)
 
84
 
 
85
    def make_wrapped_streams(self, 
84
86
                             stdout_encoding,
85
87
                             stderr_encoding,
86
88
                             stdin_encoding,
92
94
        sys.stderr.encoding = stderr_encoding
93
95
        sys.stdin = StringIOWrapper()
94
96
        sys.stdin.encoding = stdin_encoding
95
 
        osutils._cached_user_encoding = user_encoding
 
97
        bzrlib.user_encoding = user_encoding
96
98
        if enable_fake_encodings:
97
99
            fake_codec.add(stdout_encoding)
98
100
            fake_codec.add(stderr_encoding)
99
101
            fake_codec.add(stdin_encoding)
100
102
 
 
103
    def _reset(self):
 
104
        sys.stdout = self._stdout
 
105
        sys.stderr = self._stderr
 
106
        sys.stdin = self._stdin
 
107
        bzrlib.user_encoding = self._user_encoding
 
108
 
101
109
    def test_get_terminal_encoding(self):
102
110
        self.make_wrapped_streams('stdout_encoding',
103
111
                                  'stderr_encoding',
111
119
        self.assertEqual('stdin_encoding', osutils.get_terminal_encoding())
112
120
 
113
121
        sys.stdin.encoding = None
114
 
        # and in the worst case, use osutils.get_user_encoding()
 
122
        # and in the worst case, use bzrlib.user_encoding
115
123
        self.assertEqual('user_encoding', osutils.get_terminal_encoding())
116
124
 
117
 
    def test_get_terminal_encoding_silent(self):
118
 
        self.make_wrapped_streams('stdout_encoding',
119
 
                                  'stderr_encoding',
120
 
                                  'stdin_encoding')
121
 
        # Calling get_terminal_encoding should not mutter when silent=True is
122
 
        # passed.
123
 
        log = self.get_log()
124
 
        osutils.get_terminal_encoding()
125
 
        self.assertEqual(log, self.get_log())
126
 
 
127
 
    def test_get_terminal_encoding_trace(self):
128
 
        self.make_wrapped_streams('stdout_encoding',
129
 
                                  'stderr_encoding',
130
 
                                  'stdin_encoding')
131
 
        # Calling get_terminal_encoding should not mutter when silent=True is
132
 
        # passed.
133
 
        log = self.get_log()
134
 
        osutils.get_terminal_encoding(trace=True)
135
 
        self.assertNotEqual(log, self.get_log())
136
 
 
137
125
    def test_terminal_cp0(self):
138
126
        # test cp0 encoding (Windows returns cp0 when there is no encoding)
139
127
        self.make_wrapped_streams('cp0',
156
144
                                  'cp-unknown',
157
145
                                  user_encoding='latin-1',
158
146
                                  enable_fake_encodings=False)
159
 
 
 
147
        
160
148
        self.assertEqual('latin-1', osutils.get_terminal_encoding())
161
149
 
162
150
        # check stderr
163
151
        self.assertEquals('bzr: warning: unknown terminal encoding cp-unknown.\n'
164
 
                          '  Using encoding latin-1 instead.\n',
 
152
                          '  Using encoding latin-1 instead.\n', 
165
153
                          sys.stderr.getvalue())
166
154
 
167
155
 
168
156
class TestUserEncoding(TestCase):
169
157
    """Test detection of default user encoding."""
170
 
 
 
158
    
171
159
    def setUp(self):
172
 
        TestCase.setUp(self)
173
 
        self.overrideAttr(locale, 'getpreferredencoding')
174
 
        self.addCleanup(osutils.set_or_unset_env,
175
 
                        'LANG', os.environ.get('LANG'))
176
 
        self.overrideAttr(sys, 'stderr', StringIOWrapper())
 
160
        self._stderr = sys.stderr
 
161
        self._getpreferredencoding = locale.getpreferredencoding
 
162
        self.addCleanup(self._reset)
 
163
        sys.stderr = StringIOWrapper()
 
164
        # save $LANG
 
165
        self._LANG = os.environ.get('LANG')
 
166
 
 
167
    def _reset(self):
 
168
        locale.getpreferredencoding = self._getpreferredencoding
 
169
        sys.stderr = self._stderr
 
170
        # restore $LANG
 
171
        osutils.set_or_unset_env('LANG', self._LANG)
177
172
 
178
173
    def test_get_user_encoding(self):
179
174
        def f():
202
197
                          ' Continuing with ascii encoding.\n',
203
198
                          sys.stderr.getvalue())
204
199
 
205
 
    def test_user_empty(self):
206
 
        """Running bzr from a vim script gives '' for a preferred locale"""
207
 
        def f():
208
 
            return ''
209
 
 
210
 
        locale.getpreferredencoding = f
211
 
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
212
 
        self.assertEquals('', sys.stderr.getvalue())
213
 
 
214
200
    def test_user_locale_error(self):
215
201
        def f():
216
202
            raise locale.Error, 'unsupported locale'