← 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

(jameinel) Allow 'bzr serve' to interpret SIGHUP as a graceful shutdown.
 (bug #795025) (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
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')
165
 
 
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)
 
170
        TestCase.setUp(self)
 
171
        self.overrideAttr(locale, 'getpreferredencoding')
 
172
        self.overrideAttr(sys, 'stderr', StringIOWrapper())
171
173
 
172
174
    def test_get_user_encoding(self):
173
175
        def f():
175
177
 
176
178
        locale.getpreferredencoding = f
177
179
        fake_codec.add('user_encoding')
178
 
        self.assertEquals('user_encoding', osutils.get_user_encoding(use_cache=False))
 
180
        self.assertEquals('user_encoding',
 
181
                          osutils.get_user_encoding(use_cache=False))
179
182
        self.assertEquals('', sys.stderr.getvalue())
180
183
 
181
184
    def test_user_cp0(self):
210
213
            raise locale.Error, 'unsupported locale'
211
214
 
212
215
        locale.getpreferredencoding = f
213
 
        os.environ['LANG'] = 'BOGUS'
 
216
        self.overrideEnv('LANG', 'BOGUS')
214
217
        self.assertEquals('ascii', osutils.get_user_encoding(use_cache=False))
215
218
        self.assertEquals('bzr: warning: unsupported locale\n'
216
219
                          '  Could not determine what text encoding to use.\n'