test_util.py 11 KB
Newer Older
1 2 3 4
"""Tests for distutils.util."""
import os
import sys
import unittest
5
from copy import copy
6
from test.support import run_unittest
7

8
from distutils.errors import DistutilsPlatformError, DistutilsByteCompileError
9
from distutils.util import (get_platform, convert_path, change_root,
10
                            check_environ, split_quoted, strtobool,
11 12
                            rfc822_escape, byte_compile,
                            grok_environment_error)
13 14 15
from distutils import util # used to patch _environ_checked
from distutils.sysconfig import get_config_vars
from distutils import sysconfig
16
from distutils.tests import support
17
import _osx_support
18

19
class UtilTestCase(support.EnvironGuard, unittest.TestCase):
20 21

    def setUp(self):
22
        super(UtilTestCase, self).setUp()
23 24 25 26 27 28 29 30
        # saving the environment
        self.name = os.name
        self.platform = sys.platform
        self.version = sys.version
        self.sep = os.sep
        self.join = os.path.join
        self.isabs = os.path.isabs
        self.splitdrive = os.path.splitdrive
31
        self._config_vars = copy(sysconfig._config_vars)
32 33 34 35 36 37 38 39

        # patching os.uname
        if hasattr(os, 'uname'):
            self.uname = os.uname
            self._uname = os.uname()
        else:
            self.uname = None
            self._uname = None
40

41
        os.uname = self._get_uname
42

43
    def tearDown(self):
44
        # getting back the environment
45 46 47 48 49 50 51 52 53
        os.name = self.name
        sys.platform = self.platform
        sys.version = self.version
        os.sep = self.sep
        os.path.join = self.join
        os.path.isabs = self.isabs
        os.path.splitdrive = self.splitdrive
        if self.uname is not None:
            os.uname = self.uname
54 55
        else:
            del os.uname
56
        sysconfig._config_vars = copy(self._config_vars)
57
        super(UtilTestCase, self).tearDown()
58 59 60 61 62 63 64

    def _set_uname(self, uname):
        self._uname = uname

    def _get_uname(self):
        return self._uname

65
    def test_get_platform(self):
66 67 68 69 70 71

        # windows XP, 32bits
        os.name = 'nt'
        sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
                       '[MSC v.1310 32 bit (Intel)]')
        sys.platform = 'win32'
72
        self.assertEqual(get_platform(), 'win32')
73 74 75 76 77 78

        # windows XP, amd64
        os.name = 'nt'
        sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
                       '[MSC v.1310 32 bit (Amd64)]')
        sys.platform = 'win32'
79
        self.assertEqual(get_platform(), 'win-amd64')
80 81 82 83 84 85

        # windows XP, itanium
        os.name = 'nt'
        sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
                       '[MSC v.1310 32 bit (Itanium)]')
        sys.platform = 'win32'
86
        self.assertEqual(get_platform(), 'win-ia64')
87 88 89 90 91 92 93 94 95 96

        # macbook
        os.name = 'posix'
        sys.version = ('2.5 (r25:51918, Sep 19 2006, 08:49:13) '
                       '\n[GCC 4.0.1 (Apple Computer, Inc. build 5341)]')
        sys.platform = 'darwin'
        self._set_uname(('Darwin', 'macziade', '8.11.1',
                   ('Darwin Kernel Version 8.11.1: '
                    'Wed Oct 10 18:23:28 PDT 2007; '
                    'root:xnu-792.25.20~1/RELEASE_I386'), 'i386'))
97
        _osx_support._remove_original_values(get_config_vars())
98
        get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = '10.3'
99 100 101 102 103 104 105

        get_config_vars()['CFLAGS'] = ('-fno-strict-aliasing -DNDEBUG -g '
                                       '-fwrapv -O3 -Wall -Wstrict-prototypes')

        cursize = sys.maxsize
        sys.maxsize = (2 ** 31)-1
        try:
106
            self.assertEqual(get_platform(), 'macosx-10.3-i386')
107 108 109 110
        finally:
            sys.maxsize = cursize

        # macbook with fat binaries (fat, universal or fat64)
111
        _osx_support._remove_original_values(get_config_vars())
112
        get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = '10.4'
113 114 115 116 117
        get_config_vars()['CFLAGS'] = ('-arch ppc -arch i386 -isysroot '
                                       '/Developer/SDKs/MacOSX10.4u.sdk  '
                                       '-fno-strict-aliasing -fno-common '
                                       '-dynamic -DNDEBUG -g -O3')

118
        self.assertEqual(get_platform(), 'macosx-10.4-fat')
119

120
        _osx_support._remove_original_values(get_config_vars())
121 122 123 124
        os.environ['MACOSX_DEPLOYMENT_TARGET'] = '10.1'
        self.assertEqual(get_platform(), 'macosx-10.4-fat')


125
        _osx_support._remove_original_values(get_config_vars())
126 127 128 129 130
        get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch i386 -isysroot '
                                       '/Developer/SDKs/MacOSX10.4u.sdk  '
                                       '-fno-strict-aliasing -fno-common '
                                       '-dynamic -DNDEBUG -g -O3')

131
        self.assertEqual(get_platform(), 'macosx-10.4-intel')
132

133
        _osx_support._remove_original_values(get_config_vars())
134 135 136 137
        get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc -arch i386 -isysroot '
                                       '/Developer/SDKs/MacOSX10.4u.sdk  '
                                       '-fno-strict-aliasing -fno-common '
                                       '-dynamic -DNDEBUG -g -O3')
138
        self.assertEqual(get_platform(), 'macosx-10.4-fat3')
139

140
        _osx_support._remove_original_values(get_config_vars())
141 142 143 144
        get_config_vars()['CFLAGS'] = ('-arch ppc64 -arch x86_64 -arch ppc -arch i386 -isysroot '
                                       '/Developer/SDKs/MacOSX10.4u.sdk  '
                                       '-fno-strict-aliasing -fno-common '
                                       '-dynamic -DNDEBUG -g -O3')
145
        self.assertEqual(get_platform(), 'macosx-10.4-universal')
146

147
        _osx_support._remove_original_values(get_config_vars())
148 149 150 151 152
        get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc64 -isysroot '
                                       '/Developer/SDKs/MacOSX10.4u.sdk  '
                                       '-fno-strict-aliasing -fno-common '
                                       '-dynamic -DNDEBUG -g -O3')

153
        self.assertEqual(get_platform(), 'macosx-10.4-fat64')
154 155

        for arch in ('ppc', 'i386', 'x86_64', 'ppc64'):
156
            _osx_support._remove_original_values(get_config_vars())
157 158 159 160 161
            get_config_vars()['CFLAGS'] = ('-arch %s -isysroot '
                                           '/Developer/SDKs/MacOSX10.4u.sdk  '
                                           '-fno-strict-aliasing -fno-common '
                                           '-dynamic -DNDEBUG -g -O3'%(arch,))

162
            self.assertEqual(get_platform(), 'macosx-10.4-%s'%(arch,))
163

164

165 166 167 168 169 170 171 172
        # linux debian sarge
        os.name = 'posix'
        sys.version = ('2.3.5 (#1, Jul  4 2007, 17:28:59) '
                       '\n[GCC 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)]')
        sys.platform = 'linux2'
        self._set_uname(('Linux', 'aglae', '2.6.21.1dedibox-r7',
                    '#1 Mon Apr 30 17:25:38 CEST 2007', 'i686'))

173
        self.assertEqual(get_platform(), 'linux-i686')
174 175

        # XXX more platforms to tests here
176 177 178 179 180 181 182 183

    def test_convert_path(self):
        # linux/mac
        os.sep = '/'
        def _join(path):
            return '/'.join(path)
        os.path.join = _join

184 185
        self.assertEqual(convert_path('/home/to/my/stuff'),
                         '/home/to/my/stuff')
186 187 188 189 190 191 192 193 194 195

        # win
        os.sep = '\\'
        def _join(*path):
            return '\\'.join(path)
        os.path.join = _join

        self.assertRaises(ValueError, convert_path, '/home/to/my/stuff')
        self.assertRaises(ValueError, convert_path, 'home/to/my/stuff/')

196 197 198 199
        self.assertEqual(convert_path('home/to/my/stuff'),
                         'home\\to\\my\\stuff')
        self.assertEqual(convert_path('.'),
                         os.curdir)
200 201 202 203 204 205 206

    def test_change_root(self):
        # linux/mac
        os.name = 'posix'
        def _isabs(path):
            return path[0] == '/'
        os.path.isabs = _isabs
207 208 209
        def _join(*path):
            return '/'.join(path)
        os.path.join = _join
210

211 212 213 214
        self.assertEqual(change_root('/root', '/old/its/here'),
                         '/root/old/its/here')
        self.assertEqual(change_root('/root', 'its/here'),
                         '/root/its/here')
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229

        # windows
        os.name = 'nt'
        def _isabs(path):
            return path.startswith('c:\\')
        os.path.isabs = _isabs
        def _splitdrive(path):
            if path.startswith('c:'):
                return ('', path.replace('c:', ''))
            return ('', path)
        os.path.splitdrive = _splitdrive
        def _join(*path):
            return '\\'.join(path)
        os.path.join = _join

230 231 232 233
        self.assertEqual(change_root('c:\\root', 'c:\\old\\its\\here'),
                         'c:\\root\\old\\its\\here')
        self.assertEqual(change_root('c:\\root', 'its\\here'),
                         'c:\\root\\its\\here')
234 235 236 237 238 239

        # BugsBunny os (it's a great os)
        os.name = 'BugsBunny'
        self.assertRaises(DistutilsPlatformError,
                          change_root, 'c:\\root', 'its\\here')

240
        # XXX platforms to be covered: mac
241 242 243

    def test_check_environ(self):
        util._environ_checked = 0
244 245
        if 'HOME' in os.environ:
            del os.environ['HOME']
246 247 248

        # posix without HOME
        if os.name == 'posix':  # this test won't run on windows
249 250
            check_environ()
            import pwd
251
            self.assertEqual(os.environ['HOME'], pwd.getpwuid(os.getuid())[5])
252 253 254
        else:
            check_environ()

255 256
        self.assertEqual(os.environ['PLAT'], get_platform())
        self.assertEqual(util._environ_checked, 1)
257 258

    def test_split_quoted(self):
259 260
        self.assertEqual(split_quoted('""one"" "two" \'three\' \\four'),
                         ['one', 'two', 'three', 'four'])
261 262 263 264 265 266

    def test_strtobool(self):
        yes = ('y', 'Y', 'yes', 'True', 't', 'true', 'True', 'On', 'on', '1')
        no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N')

        for y in yes:
267
            self.assertTrue(strtobool(y))
268 269

        for n in no:
270
            self.assertFalse(strtobool(n))
271 272 273 274 275 276

    def test_rfc822_escape(self):
        header = 'I am a\npoor\nlonesome\nheader\n'
        res = rfc822_escape(header)
        wanted = ('I am a%(8s)spoor%(8s)slonesome%(8s)s'
                  'header%(8s)s') % {'8s': '\n'+8*' '}
277
        self.assertEqual(res, wanted)
278

279 280 281 282 283 284 285 286 287 288
    def test_dont_write_bytecode(self):
        # makes sure byte_compile raise a DistutilsError
        # if sys.dont_write_bytecode is True
        old_dont_write_bytecode = sys.dont_write_bytecode
        sys.dont_write_bytecode = True
        try:
            self.assertRaises(DistutilsByteCompileError, byte_compile, [])
        finally:
            sys.dont_write_bytecode = old_dont_write_bytecode

289 290 291 292 293 294 295
    def test_grok_environment_error(self):
        # test obsolete function to ensure backward compat (#4931)
        exc = IOError("Unable to find batch file")
        msg = grok_environment_error(exc)
        self.assertEqual(msg, "error: Unable to find batch file")


296
def test_suite():
297
    return unittest.makeSuite(UtilTestCase)
298 299

if __name__ == "__main__":
300
    run_unittest(test_suite())