1  """Tests for distutils.unixccompiler."""
       2  import sys
       3  import unittest
       4  from test.support.os_helper import EnvironmentVarGuard
       5  
       6  from distutils import sysconfig
       7  from distutils.unixccompiler import UnixCCompiler
       8  
       9  class ESC[4;38;5;81mUnixCCompilerTestCase(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
      10  
      11      def setUp(self):
      12          self._backup_platform = sys.platform
      13          self._backup_get_config_var = sysconfig.get_config_var
      14          self._backup_config_vars = dict(sysconfig._config_vars)
      15          class ESC[4;38;5;81mCompilerWrapper(ESC[4;38;5;149mUnixCCompiler):
      16              def rpath_foo(self):
      17                  return self.runtime_library_dir_option('/foo')
      18          self.cc = CompilerWrapper()
      19  
      20      def tearDown(self):
      21          sys.platform = self._backup_platform
      22          sysconfig.get_config_var = self._backup_get_config_var
      23          sysconfig._config_vars.clear()
      24          sysconfig._config_vars.update(self._backup_config_vars)
      25  
      26      @unittest.skipIf(sys.platform == 'win32', "can't test on Windows")
      27      def test_runtime_libdir_option(self):
      28          # Issue#5900
      29          #
      30          # Ensure RUNPATH is added to extension modules with RPATH if
      31          # GNU ld is used
      32  
      33          # darwin
      34          sys.platform = 'darwin'
      35          self.assertEqual(self.cc.rpath_foo(), '-L/foo')
      36  
      37          # hp-ux
      38          sys.platform = 'hp-ux'
      39          old_gcv = sysconfig.get_config_var
      40          def gcv(v):
      41              return 'xxx'
      42          sysconfig.get_config_var = gcv
      43          self.assertEqual(self.cc.rpath_foo(), ['+s', '-L/foo'])
      44  
      45          def gcv(v):
      46              return 'gcc'
      47          sysconfig.get_config_var = gcv
      48          self.assertEqual(self.cc.rpath_foo(), ['-Wl,+s', '-L/foo'])
      49  
      50          def gcv(v):
      51              return 'g++'
      52          sysconfig.get_config_var = gcv
      53          self.assertEqual(self.cc.rpath_foo(), ['-Wl,+s', '-L/foo'])
      54  
      55          sysconfig.get_config_var = old_gcv
      56  
      57          # GCC GNULD
      58          sys.platform = 'bar'
      59          def gcv(v):
      60              if v == 'CC':
      61                  return 'gcc'
      62              elif v == 'GNULD':
      63                  return 'yes'
      64          sysconfig.get_config_var = gcv
      65          self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')
      66  
      67          # GCC non-GNULD
      68          sys.platform = 'bar'
      69          def gcv(v):
      70              if v == 'CC':
      71                  return 'gcc'
      72              elif v == 'GNULD':
      73                  return 'no'
      74          sysconfig.get_config_var = gcv
      75          self.assertEqual(self.cc.rpath_foo(), '-Wl,-R/foo')
      76  
      77          # GCC GNULD with fully qualified configuration prefix
      78          # see #7617
      79          sys.platform = 'bar'
      80          def gcv(v):
      81              if v == 'CC':
      82                  return 'x86_64-pc-linux-gnu-gcc-4.4.2'
      83              elif v == 'GNULD':
      84                  return 'yes'
      85          sysconfig.get_config_var = gcv
      86          self.assertEqual(self.cc.rpath_foo(), '-Wl,--enable-new-dtags,-R/foo')
      87  
      88          # non-GCC GNULD
      89          sys.platform = 'bar'
      90          def gcv(v):
      91              if v == 'CC':
      92                  return 'cc'
      93              elif v == 'GNULD':
      94                  return 'yes'
      95          sysconfig.get_config_var = gcv
      96          self.assertEqual(self.cc.rpath_foo(), '-R/foo')
      97  
      98          # non-GCC non-GNULD
      99          sys.platform = 'bar'
     100          def gcv(v):
     101              if v == 'CC':
     102                  return 'cc'
     103              elif v == 'GNULD':
     104                  return 'no'
     105          sysconfig.get_config_var = gcv
     106          self.assertEqual(self.cc.rpath_foo(), '-R/foo')
     107  
     108      @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for OS X')
     109      def test_osx_cc_overrides_ldshared(self):
     110          # Issue #18080:
     111          # ensure that setting CC env variable also changes default linker
     112          def gcv(v):
     113              if v == 'LDSHARED':
     114                  return 'gcc-4.2 -bundle -undefined dynamic_lookup '
     115              return 'gcc-4.2'
     116          sysconfig.get_config_var = gcv
     117          with EnvironmentVarGuard() as env:
     118              env['CC'] = 'my_cc'
     119              del env['LDSHARED']
     120              sysconfig.customize_compiler(self.cc)
     121          self.assertEqual(self.cc.linker_so[0], 'my_cc')
     122  
     123      @unittest.skipUnless(sys.platform == 'darwin', 'test only relevant for OS X')
     124      def test_osx_explicit_ldshared(self):
     125          # Issue #18080:
     126          # ensure that setting CC env variable does not change
     127          #   explicit LDSHARED setting for linker
     128          def gcv(v):
     129              if v == 'LDSHARED':
     130                  return 'gcc-4.2 -bundle -undefined dynamic_lookup '
     131              return 'gcc-4.2'
     132          sysconfig.get_config_var = gcv
     133          with EnvironmentVarGuard() as env:
     134              env['CC'] = 'my_cc'
     135              env['LDSHARED'] = 'my_ld -bundle -dynamic'
     136              sysconfig.customize_compiler(self.cc)
     137          self.assertEqual(self.cc.linker_so[0], 'my_ld')
     138  
     139  
     140  if __name__ == "__main__":
     141      unittest.main()