Merged revisions 74024 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r74024 | tarek.ziade | 2009-07-16 17:35:45 +0200 (Thu, 16 Jul 2009) | 1 line

  #6466 refactored distutils duplicate get_versions() functions (used to get gcc/ld/dllwrap versions)
........

1 files changed, 94 insertions, 3 deletions

diff --git a/Lib/distutils/tests/test_util.py b/Lib/distutils/tests/test_util.py
index c0acf5f..e9065ff 100644
--- a/Lib/distutils/tests/test_util.py
+++ b/Lib/distutils/tests/test_util.py
@@ -6,15 +6,33 @@ import os
 import sys
 import unittest
 from copy import copy
+from io import BytesIO
+import subprocess
 
 from distutils.errors import DistutilsPlatformError
 from distutils.util import (get_platform, convert_path, change_root,
                             check_environ, split_quoted, strtobool,
-                            rfc822_escape)
-from distutils import util # used to patch _environ_checked
+                            rfc822_escape, get_compiler_versions,
+                            _find_exe_version, _MAC_OS_X_LD_VERSION)
+from distutils import util
 from distutils.sysconfig import get_config_vars
 from distutils import sysconfig
 from distutils.tests import support
+from distutils.version import LooseVersion
+
+class FakePopen(object):
+    test_class = None
+    def __init__(self, cmd, shell, stdout, stderr):
+        self.cmd = cmd.split()[0]
+        exes = self.test_class._exes
+        if self.cmd not in exes:
+            # we don't want to call the system, returning an empty
+            # output so it doesn't match
+            self.stdout = BytesIO()
+            self.stderr = BytesIO()
+        else:
+            self.stdout = BytesIO(exes[self.cmd])
+            self.stderr = BytesIO()
 
 class UtilTestCase(support.EnvironGuard, unittest.TestCase):
 
@@ -37,9 +55,16 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase):
         else:
             self.uname = None
             self._uname = None
-
         os.uname = self._get_uname
 
+        # patching POpen
+        self.old_find_executable = util.find_executable
+        util.find_executable = self._find_executable
+        self._exes = {}
+        self.old_popen = subprocess.Popen
+        FakePopen.test_class = self
+        subprocess.Popen = FakePopen
+
     def tearDown(self):
         # getting back the environment
         os.name = self.name
@@ -54,6 +79,8 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase):
         else:
             del os.uname
         sysconfig._config_vars = copy(self._config_vars)
+        util.find_executable = self.old_find_executable
+        subprocess.Popen = self.old_popen
         super(UtilTestCase, self).tearDown()
 
     def _set_uname(self, uname):
@@ -237,6 +264,70 @@ class UtilTestCase(support.EnvironGuard, unittest.TestCase):
                   'header%(8s)s') % {'8s': '\n'+8*' '}
         self.assertEquals(res, wanted)
 
+    def test_find_exe_version(self):
+        # the ld version scheme under MAC OS is:
+        #   ^@(#)PROGRAM:ld  PROJECT:ld64-VERSION
+        #
+        # where VERSION is a 2-digit number for major
+        # revisions. For instance under Leopard, it's
+        # currently 77
+        #
+        # Dots are used when branching is done.
+        #
+        # The SnowLeopard ld64 is currently 95.2.12
+
+        for output, version in ((b'@(#)PROGRAM:ld  PROJECT:ld64-77', '77'),
+                                (b'@(#)PROGRAM:ld  PROJECT:ld64-95.2.12',
+                                 '95.2.12')):
+            result = _MAC_OS_X_LD_VERSION.search(output)
+            self.assertEquals(result.group(1).decode(), version)
+
+    def _find_executable(self, name):
+        if name in self._exes:
+            return name
+        return None
+
+    def test_get_compiler_versions(self):
+        # get_versions calls distutils.spawn.find_executable on
+        # 'gcc', 'ld' and 'dllwrap'
+        self.assertEquals(get_compiler_versions(), (None, None, None))
+
+        # Let's fake we have 'gcc' and it returns '3.4.5'
+        self._exes['gcc'] = b'gcc (GCC) 3.4.5 (mingw special)\nFSF'
+        res = get_compiler_versions()
+        self.assertEquals(str(res[0]), '3.4.5')
+
+        # and let's see what happens when the version
+        # doesn't match the regular expression
+        # (\d+\.\d+(\.\d+)*)
+        self._exes['gcc'] = b'very strange output'
+        res = get_compiler_versions()
+        self.assertEquals(res[0], None)
+
+        # same thing for ld
+        if sys.platform != 'darwin':
+            self._exes['ld'] = b'GNU ld version 2.17.50 20060824'
+            res = get_compiler_versions()
+            self.assertEquals(str(res[1]), '2.17.50')
+            self._exes['ld'] = b'@(#)PROGRAM:ld  PROJECT:ld64-77'
+            res = get_compiler_versions()
+            self.assertEquals(res[1], None)
+        else:
+            self._exes['ld'] = b'GNU ld version 2.17.50 20060824'
+            res = get_compiler_versions()
+            self.assertEquals(res[1], None)
+            self._exes['ld'] = b'@(#)PROGRAM:ld  PROJECT:ld64-77'
+            res = get_compiler_versions()
+            self.assertEquals(str(res[1]), '77')
+
+        # and dllwrap
+        self._exes['dllwrap'] = b'GNU dllwrap 2.17.50 20060824\nFSF'
+        res = get_compiler_versions()
+        self.assertEquals(str(res[2]), '2.17.50')
+        self._exes['dllwrap'] = b'Cheese Wrap'
+        res = get_compiler_versions()
+        self.assertEquals(res[2], None)
+
 def test_suite():
     return unittest.makeSuite(UtilTestCase)