AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_sysconfig.py

   1 """Tests for 'site'.
   2
   3 Tests assume the initial paths in sys.path once the interpreter has begun
   4 executing have not been removed.
   5
   6 """
   7 import unittest
   8 import sys
   9 import os
  10 import shutil
  11 import subprocess
  12 from copy import copy, deepcopy
  13
  14 from test.test_support import run_unittest, TESTFN, unlink, get_attribute
  15
  16 import sysconfig
  17 from sysconfig import (get_paths, get_platform, get_config_vars,
  18                        get_path, get_path_names, _INSTALL_SCHEMES,
  19                        _get_default_scheme, _expand_vars,
  20                        get_scheme_names, get_config_var)
  21
  22 class TestSysConfig(unittest.TestCase):
  23
  24     def setUp(self):
  25         """Make a copy of sys.path"""
  26         super(TestSysConfig, self).setUp()
  27         self.sys_path = sys.path[:]
  28         self.makefile = None
  29         # patching os.uname
  30         if hasattr(os, 'uname'):
  31             self.uname = os.uname
  32             self._uname = os.uname()
  33         else:
  34             self.uname = None
  35             self._uname = None
  36         os.uname = self._get_uname
  37         # saving the environment
  38         self.name = os.name
  39         self.platform = sys.platform
  40         self.version = sys.version
  41         self.sep = os.sep
  42         self.join = os.path.join
  43         self.isabs = os.path.isabs
  44         self.splitdrive = os.path.splitdrive
  45         self._config_vars = copy(sysconfig._CONFIG_VARS)
  46         self.old_environ = deepcopy(os.environ)
  47
  48     def tearDown(self):
  49         """Restore sys.path"""
  50         sys.path[:] = self.sys_path
  51         if self.makefile is not None:
  52             os.unlink(self.makefile)
  53         self._cleanup_testfn()
  54         if self.uname is not None:
  55             os.uname = self.uname
  56         else:
  57             del os.uname
  58         os.name = self.name
  59         sys.platform = self.platform
  60         sys.version = self.version
  61         os.sep = self.sep
  62         os.path.join = self.join
  63         os.path.isabs = self.isabs
  64         os.path.splitdrive = self.splitdrive
  65         sysconfig._CONFIG_VARS = copy(self._config_vars)
  66         for key, value in self.old_environ.items():
  67             if os.environ.get(key) != value:
  68                 os.environ[key] = value
  69
  70         for key in os.environ.keys():
  71             if key not in self.old_environ:
  72                 del os.environ[key]
  73
  74         super(TestSysConfig, self).tearDown()
  75
  76     def _set_uname(self, uname):
  77         self._uname = uname
  78
  79     def _get_uname(self):
  80         return self._uname
  81
  82     def _cleanup_testfn(self):
  83         path = TESTFN
  84         if os.path.isfile(path):
  85             os.remove(path)
  86         elif os.path.isdir(path):
  87             shutil.rmtree(path)
  88
  89     def test_get_path_names(self):
  90         self.assertEqual(get_path_names(), sysconfig._SCHEME_KEYS)
  91
  92     def test_get_paths(self):
  93         scheme = get_paths()
  94         default_scheme = _get_default_scheme()
  95         wanted = _expand_vars(default_scheme, None)
  96         wanted = wanted.items()
  97         wanted.sort()
  98         scheme = scheme.items()
  99         scheme.sort()
 100         self.assertEqual(scheme, wanted)
 101
 102     def test_get_path(self):
 103         # xxx make real tests here
 104         for scheme in _INSTALL_SCHEMES:
 105             for name in _INSTALL_SCHEMES[scheme]:
 106                 res = get_path(name, scheme)
 107
 108     def test_get_config_vars(self):
 109         cvars = get_config_vars()
 110         self.assertIsInstance(cvars, dict)
 111         self.assertTrue(cvars)
 112
 113     def test_get_platform(self):
 114         # windows XP, 32bits
 115         os.name = 'nt'
 116         sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
 117                        '[MSC v.1310 32 bit (Intel)]')
 118         sys.platform = 'win32'
 119         self.assertEqual(get_platform(), 'win32')
 120
 121         # windows XP, amd64
 122         os.name = 'nt'
 123         sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
 124                        '[MSC v.1310 32 bit (Amd64)]')
 125         sys.platform = 'win32'
 126         self.assertEqual(get_platform(), 'win-amd64')
 127
 128         # windows XP, itanium
 129         os.name = 'nt'
 130         sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
 131                        '[MSC v.1310 32 bit (Itanium)]')
 132         sys.platform = 'win32'
 133         self.assertEqual(get_platform(), 'win-ia64')
 134
 135         # macbook
 136         os.name = 'posix'
 137         sys.version = ('2.5 (r25:51918, Sep 19 2006, 08:49:13) '
 138                        '\n[GCC 4.0.1 (Apple Computer, Inc. build 5341)]')
 139         sys.platform = 'darwin'
 140         self._set_uname(('Darwin', 'macziade', '8.11.1',
 141                    ('Darwin Kernel Version 8.11.1: '
 142                     'Wed Oct 10 18:23:28 PDT 2007; '
 143                     'root:xnu-792.25.20~1/RELEASE_I386'), 'PowerPC'))
 144         get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = '10.3'
 145
 146         get_config_vars()['CFLAGS'] = ('-fno-strict-aliasing -DNDEBUG -g '
 147                                        '-fwrapv -O3 -Wall -Wstrict-prototypes')
 148
 149         maxint = sys.maxint
 150         try:
 151             sys.maxint = 2147483647
 152             self.assertEqual(get_platform(), 'macosx-10.3-ppc')
 153             sys.maxint = 9223372036854775807
 154             self.assertEqual(get_platform(), 'macosx-10.3-ppc64')
 155         finally:
 156             sys.maxint = maxint
 157
 158
 159         self._set_uname(('Darwin', 'macziade', '8.11.1',
 160                    ('Darwin Kernel Version 8.11.1: '
 161                     'Wed Oct 10 18:23:28 PDT 2007; '
 162                     'root:xnu-792.25.20~1/RELEASE_I386'), 'i386'))
 163         get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = '10.3'
 164
 165         get_config_vars()['CFLAGS'] = ('-fno-strict-aliasing -DNDEBUG -g '
 166                                        '-fwrapv -O3 -Wall -Wstrict-prototypes')
 167
 168         maxint = sys.maxint
 169         try:
 170             sys.maxint = 2147483647
 171             self.assertEqual(get_platform(), 'macosx-10.3-i386')
 172             sys.maxint = 9223372036854775807
 173             self.assertEqual(get_platform(), 'macosx-10.3-x86_64')
 174         finally:
 175             sys.maxint = maxint
 176
 177         # macbook with fat binaries (fat, universal or fat64)
 178         get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = '10.4'
 179         get_config_vars()['CFLAGS'] = ('-arch ppc -arch i386 -isysroot '
 180                                        '/Developer/SDKs/MacOSX10.4u.sdk  '
 181                                        '-fno-strict-aliasing -fno-common '
 182                                        '-dynamic -DNDEBUG -g -O3')
 183
 184         self.assertEqual(get_platform(), 'macosx-10.4-fat')
 185
 186         get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch i386 -isysroot '
 187                                        '/Developer/SDKs/MacOSX10.4u.sdk  '
 188                                        '-fno-strict-aliasing -fno-common '
 189                                        '-dynamic -DNDEBUG -g -O3')
 190
 191         self.assertEqual(get_platform(), 'macosx-10.4-intel')
 192
 193         get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc -arch i386 -isysroot '
 194                                        '/Developer/SDKs/MacOSX10.4u.sdk  '
 195                                        '-fno-strict-aliasing -fno-common '
 196                                        '-dynamic -DNDEBUG -g -O3')
 197         self.assertEqual(get_platform(), 'macosx-10.4-fat3')
 198
 199         get_config_vars()['CFLAGS'] = ('-arch ppc64 -arch x86_64 -arch ppc -arch i386 -isysroot '
 200                                        '/Developer/SDKs/MacOSX10.4u.sdk  '
 201                                        '-fno-strict-aliasing -fno-common '
 202                                        '-dynamic -DNDEBUG -g -O3')
 203         self.assertEqual(get_platform(), 'macosx-10.4-universal')
 204
 205         get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc64 -isysroot '
 206                                        '/Developer/SDKs/MacOSX10.4u.sdk  '
 207                                        '-fno-strict-aliasing -fno-common '
 208                                        '-dynamic -DNDEBUG -g -O3')
 209
 210         self.assertEqual(get_platform(), 'macosx-10.4-fat64')
 211
 212         for arch in ('ppc', 'i386', 'x86_64', 'ppc64'):
 213             get_config_vars()['CFLAGS'] = ('-arch %s -isysroot '
 214                                            '/Developer/SDKs/MacOSX10.4u.sdk  '
 215                                            '-fno-strict-aliasing -fno-common '
 216                                            '-dynamic -DNDEBUG -g -O3'%(arch,))
 217
 218             self.assertEqual(get_platform(), 'macosx-10.4-%s'%(arch,))
 219
 220         # linux debian sarge
 221         os.name = 'posix'
 222         sys.version = ('2.3.5 (#1, Jul  4 2007, 17:28:59) '
 223                        '\n[GCC 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)]')
 224         sys.platform = 'linux2'
 225         self._set_uname(('Linux', 'aglae', '2.6.21.1dedibox-r7',
 226                     '#1 Mon Apr 30 17:25:38 CEST 2007', 'i686'))
 227
 228         self.assertEqual(get_platform(), 'linux-i686')
 229
 230         # XXX more platforms to tests here
 231
 232     def test_get_config_h_filename(self):
 233         config_h = sysconfig.get_config_h_filename()
 234         self.assertTrue(os.path.isfile(config_h), config_h)
 235
 236     def test_get_scheme_names(self):
 237         wanted = ('nt', 'nt_user', 'os2', 'os2_home', 'osx_framework_user',
 238                   'posix_home', 'posix_prefix', 'posix_user')
 239         self.assertEqual(get_scheme_names(), wanted)
 240
 241     def test_symlink(self):
 242         # Issue 7880
 243         symlink = get_attribute(os, "symlink")
 244         def get(python):
 245             cmd = [python, '-c',
 246                    'import sysconfig; print sysconfig.get_platform()']
 247             p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
 248             return p.communicate()
 249         real = os.path.realpath(sys.executable)
 250         link = os.path.abspath(TESTFN)
 251         symlink(real, link)
 252         try:
 253             self.assertEqual(get(real), get(link))
 254         finally:
 255             unlink(link)
 256
 257     def test_user_similar(self):
 258         # Issue 8759 : make sure the posix scheme for the users
 259         # is similar to the global posix_prefix one
 260         base = get_config_var('base')
 261         user = get_config_var('userbase')
 262         for name in ('stdlib', 'platstdlib', 'purelib', 'platlib'):
 263             global_path = get_path(name, 'posix_prefix')
 264             user_path = get_path(name, 'posix_user')
 265             self.assertEqual(user_path, global_path.replace(base, user))
 266
 267     @unittest.skipUnless(sys.platform == "darwin", "test only relevant on MacOSX")
 268     def test_platform_in_subprocess(self):
 269         my_platform = sysconfig.get_platform()
 270
 271         # Test without MACOSX_DEPLOYMENT_TARGET in the environment
 272
 273         env = os.environ.copy()
 274         if 'MACOSX_DEPLOYMENT_TARGET' in env:
 275             del env['MACOSX_DEPLOYMENT_TARGET']
 276
 277         with open('/dev/null', 'w') as devnull_fp:
 278             p = subprocess.Popen([
 279                     sys.executable, '-c',
 280                    'import sysconfig; print(sysconfig.get_platform())',
 281                 ],
 282                 stdout=subprocess.PIPE,
 283                 stderr=devnull_fp,
 284                 env=env)
 285         test_platform = p.communicate()[0].strip()
 286         test_platform = test_platform.decode('utf-8')
 287         status = p.wait()
 288
 289         self.assertEqual(status, 0)
 290         self.assertEqual(my_platform, test_platform)
 291
 292
 293         # Test with MACOSX_DEPLOYMENT_TARGET in the environment, and
 294         # using a value that is unlikely to be the default one.
 295         env = os.environ.copy()
 296         env['MACOSX_DEPLOYMENT_TARGET'] = '10.1'
 297
 298         p = subprocess.Popen([
 299                 sys.executable, '-c',
 300                 'import sysconfig; print(sysconfig.get_platform())',
 301             ],
 302             stdout=subprocess.PIPE,
 303             stderr=open('/dev/null'),
 304             env=env)
 305         test_platform = p.communicate()[0].strip()
 306         test_platform = test_platform.decode('utf-8')
 307         status = p.wait()
 308
 309         self.assertEqual(status, 0)
 310         self.assertEqual(my_platform, test_platform)
 311
 312 def test_main():
 313     run_unittest(TestSysConfig)
 314
 315 if __name__ == "__main__":
 316     test_main()