numpy 2.4.1__pp311-pypy311_pp73-macosx_14_0_arm64.whl

numpy/distutils/tests/test_ccompiler_opt_conf.py

@@ -0,0 +1,176 @@
+import unittest
+from os import sys, path
+
+is_standalone = __name__ == '__main__' and __package__ is None
+if is_standalone:
+    sys.path.append(path.abspath(path.join(path.dirname(__file__), "..")))
+    from ccompiler_opt import CCompilerOpt
+else:
+    from numpy.distutils.ccompiler_opt import CCompilerOpt
+
+arch_compilers = dict(
+    x86 = ("gcc", "clang", "icc", "iccw", "msvc"),
+    x64 = ("gcc", "clang", "icc", "iccw", "msvc"),
+    ppc64 = ("gcc", "clang"),
+    ppc64le = ("gcc", "clang"),
+    armhf = ("gcc", "clang"),
+    aarch64 = ("gcc", "clang"),
+    narch = ("gcc",)
+)
+
+class FakeCCompilerOpt(CCompilerOpt):
+    fake_info = ("arch", "compiler", "extra_args")
+    def __init__(self, *args, **kwargs):
+        CCompilerOpt.__init__(self, None, **kwargs)
+    def dist_compile(self, sources, flags, **kwargs):
+        return sources
+    def dist_info(self):
+        return FakeCCompilerOpt.fake_info
+    @staticmethod
+    def dist_log(*args, stderr=False):
+        pass
+
+class _TestConfFeatures(FakeCCompilerOpt):
+    """A hook to check the sanity of configured features
+-   before it called by the abstract class '_Feature'
+    """
+
+    def conf_features_partial(self):
+        conf_all = self.conf_features
+        for feature_name, feature in conf_all.items():
+            self.test_feature(
+                "attribute conf_features",
+                conf_all, feature_name, feature
+            )
+
+        conf_partial = FakeCCompilerOpt.conf_features_partial(self)
+        for feature_name, feature in conf_partial.items():
+            self.test_feature(
+                "conf_features_partial()",
+                conf_partial, feature_name, feature
+            )
+        return conf_partial
+
+    def test_feature(self, log, search_in, feature_name, feature_dict):
+        error_msg = (
+            "during validate '{}' within feature '{}', "
+            "march '{}' and compiler '{}'\n>> "
+        ).format(log, feature_name, self.cc_march, self.cc_name)
+
+        if not feature_name.isupper():
+            raise AssertionError(error_msg + "feature name must be in uppercase")
+
+        for option, val in feature_dict.items():
+            self.test_option_types(error_msg, option, val)
+            self.test_duplicates(error_msg, option, val)
+
+        self.test_implies(error_msg, search_in, feature_name, feature_dict)
+        self.test_group(error_msg, search_in, feature_name, feature_dict)
+        self.test_extra_checks(error_msg, search_in, feature_name, feature_dict)
+
+    def test_option_types(self, error_msg, option, val):
+        for tp, available in (
+            ((str, list), (
+                "implies", "headers", "flags", "group", "detect", "extra_checks"
+            )),
+            ((str,),  ("disable",)),
+            ((int,),  ("interest",)),
+            ((bool,), ("implies_detect",)),
+            ((bool, type(None)), ("autovec",)),
+        ) :
+            found_it = option in available
+            if not found_it:
+                continue
+            if not isinstance(val, tp):
+                error_tp = [t.__name__ for t in (*tp,)]
+                error_tp = ' or '.join(error_tp)
+                raise AssertionError(error_msg +
+                    "expected '%s' type for option '%s' not '%s'" % (
+                     error_tp, option, type(val).__name__
+                ))
+            break
+
+        if not found_it:
+            raise AssertionError(error_msg + "invalid option name '%s'" % option)
+
+    def test_duplicates(self, error_msg, option, val):
+        if option not in (
+            "implies", "headers", "flags", "group", "detect", "extra_checks"
+        ) : return
+
+        if isinstance(val, str):
+            val = val.split()
+
+        if len(val) != len(set(val)):
+            raise AssertionError(error_msg + "duplicated values in option '%s'" % option)
+
+    def test_implies(self, error_msg, search_in, feature_name, feature_dict):
+        if feature_dict.get("disabled") is not None:
+            return
+        implies = feature_dict.get("implies", "")
+        if not implies:
+            return
+        if isinstance(implies, str):
+            implies = implies.split()
+
+        if feature_name in implies:
+            raise AssertionError(error_msg + "feature implies itself")
+
+        for impl in implies:
+            impl_dict = search_in.get(impl)
+            if impl_dict is not None:
+                if "disable" in impl_dict:
+                    raise AssertionError(error_msg + "implies disabled feature '%s'" % impl)
+                continue
+            raise AssertionError(error_msg + "implies non-exist feature '%s'" % impl)
+
+    def test_group(self, error_msg, search_in, feature_name, feature_dict):
+        if feature_dict.get("disabled") is not None:
+            return
+        group = feature_dict.get("group", "")
+        if not group:
+            return
+        if isinstance(group, str):
+            group = group.split()
+
+        for f in group:
+            impl_dict = search_in.get(f)
+            if not impl_dict or "disable" in impl_dict:
+                continue
+            raise AssertionError(error_msg +
+                "in option 'group', '%s' already exists as a feature name" % f
+            )
+
+    def test_extra_checks(self, error_msg, search_in, feature_name, feature_dict):
+        if feature_dict.get("disabled") is not None:
+            return
+        extra_checks = feature_dict.get("extra_checks", "")
+        if not extra_checks:
+            return
+        if isinstance(extra_checks, str):
+            extra_checks = extra_checks.split()
+
+        for f in extra_checks:
+            impl_dict = search_in.get(f)
+            if not impl_dict or "disable" in impl_dict:
+                continue
+            raise AssertionError(error_msg +
+                "in option 'extra_checks', extra test case '%s' already exists as a feature name" % f
+            )
+
+class TestConfFeatures(unittest.TestCase):
+    def __init__(self, methodName="runTest"):
+        unittest.TestCase.__init__(self, methodName)
+        self._setup()
+
+    def _setup(self):
+        FakeCCompilerOpt.conf_nocache = True
+
+    def test_features(self):
+        for arch, compilers in arch_compilers.items():
+            for cc in compilers:
+                FakeCCompilerOpt.fake_info = (arch, cc, "")
+                _TestConfFeatures()
+
+if is_standalone:
+    unittest.main()

numpy/distutils/tests/test_exec_command.py

@@ -0,0 +1,217 @@
+import os
+import pytest
+import sys
+from tempfile import TemporaryFile
+
+from numpy.distutils import exec_command
+from numpy.distutils.exec_command import get_pythonexe
+from numpy.testing import tempdir, assert_, IS_WASM
+
+
+# In python 3 stdout, stderr are text (unicode compliant) devices, so to
+# emulate them import StringIO from the io module.
+from io import StringIO
+
+class redirect_stdout:
+    """Context manager to redirect stdout for exec_command test."""
+    def __init__(self, stdout=None):
+        self._stdout = stdout or sys.stdout
+
+    def __enter__(self):
+        self.old_stdout = sys.stdout
+        sys.stdout = self._stdout
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._stdout.flush()
+        sys.stdout = self.old_stdout
+        # note: closing sys.stdout won't close it.
+        self._stdout.close()
+
+class redirect_stderr:
+    """Context manager to redirect stderr for exec_command test."""
+    def __init__(self, stderr=None):
+        self._stderr = stderr or sys.stderr
+
+    def __enter__(self):
+        self.old_stderr = sys.stderr
+        sys.stderr = self._stderr
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._stderr.flush()
+        sys.stderr = self.old_stderr
+        # note: closing sys.stderr won't close it.
+        self._stderr.close()
+
+class emulate_nonposix:
+    """Context manager to emulate os.name != 'posix' """
+    def __init__(self, osname='non-posix'):
+        self._new_name = osname
+
+    def __enter__(self):
+        self._old_name = os.name
+        os.name = self._new_name
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        os.name = self._old_name
+
+
+def test_exec_command_stdout():
+    # Regression test for gh-2999 and gh-2915.
+    # There are several packages (nose, scipy.weave.inline, Sage inline
+    # Fortran) that replace stdout, in which case it doesn't have a fileno
+    # method.  This is tested here, with a do-nothing command that fails if the
+    # presence of fileno() is assumed in exec_command.
+
+    # The code has a special case for posix systems, so if we are on posix test
+    # both that the special case works and that the generic code works.
+
+    # Test posix version:
+    with redirect_stdout(StringIO()):
+        with redirect_stderr(TemporaryFile()):
+            with pytest.warns(DeprecationWarning):
+                exec_command.exec_command("cd '.'")
+
+    if os.name == 'posix':
+        # Test general (non-posix) version:
+        with emulate_nonposix():
+            with redirect_stdout(StringIO()):
+                with redirect_stderr(TemporaryFile()):
+                    with pytest.warns(DeprecationWarning):
+                        exec_command.exec_command("cd '.'")
+
+def test_exec_command_stderr():
+    # Test posix version:
+    with redirect_stdout(TemporaryFile(mode='w+')):
+        with redirect_stderr(StringIO()):
+            with pytest.warns(DeprecationWarning):
+                exec_command.exec_command("cd '.'")
+
+    if os.name == 'posix':
+        # Test general (non-posix) version:
+        with emulate_nonposix():
+            with redirect_stdout(TemporaryFile()):
+                with redirect_stderr(StringIO()):
+                    with pytest.warns(DeprecationWarning):
+                        exec_command.exec_command("cd '.'")
+
+
+@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
+class TestExecCommand:
+    def setup_method(self):
+        self.pyexe = get_pythonexe()
+
+    def check_nt(self, **kws):
+        s, o = exec_command.exec_command('cmd /C echo path=%path%')
+        assert_(s == 0)
+        assert_(o != '')
+
+        s, o = exec_command.exec_command(
+         '"%s" -c "import sys;sys.stderr.write(sys.platform)"' % self.pyexe)
+        assert_(s == 0)
+        assert_(o == 'win32')
+
+    def check_posix(self, **kws):
+        s, o = exec_command.exec_command("echo Hello", **kws)
+        assert_(s == 0)
+        assert_(o == 'Hello')
+
+        s, o = exec_command.exec_command('echo $AAA', **kws)
+        assert_(s == 0)
+        assert_(o == '')
+
+        s, o = exec_command.exec_command('echo "$AAA"', AAA='Tere', **kws)
+        assert_(s == 0)
+        assert_(o == 'Tere')
+
+        s, o = exec_command.exec_command('echo "$AAA"', **kws)
+        assert_(s == 0)
+        assert_(o == '')
+
+        if 'BBB' not in os.environ:
+            os.environ['BBB'] = 'Hi'
+            s, o = exec_command.exec_command('echo "$BBB"', **kws)
+            assert_(s == 0)
+            assert_(o == 'Hi')
+
+            s, o = exec_command.exec_command('echo "$BBB"', BBB='Hey', **kws)
+            assert_(s == 0)
+            assert_(o == 'Hey')
+
+            s, o = exec_command.exec_command('echo "$BBB"', **kws)
+            assert_(s == 0)
+            assert_(o == 'Hi')
+
+            del os.environ['BBB']
+
+            s, o = exec_command.exec_command('echo "$BBB"', **kws)
+            assert_(s == 0)
+            assert_(o == '')
+
+
+        s, o = exec_command.exec_command('this_is_not_a_command', **kws)
+        assert_(s != 0)
+        assert_(o != '')
+
+        s, o = exec_command.exec_command('echo path=$PATH', **kws)
+        assert_(s == 0)
+        assert_(o != '')
+
+        s, o = exec_command.exec_command(
+             '"%s" -c "import sys,os;sys.stderr.write(os.name)"' %
+             self.pyexe, **kws)
+        assert_(s == 0)
+        assert_(o == 'posix')
+
+    def check_basic(self, *kws):
+        s, o = exec_command.exec_command(
+                     '"%s" -c "raise \'Ignore me.\'"' % self.pyexe, **kws)
+        assert_(s != 0)
+        assert_(o != '')
+
+        s, o = exec_command.exec_command(
+             '"%s" -c "import sys;sys.stderr.write(\'0\');'
+             'sys.stderr.write(\'1\');sys.stderr.write(\'2\')"' %
+             self.pyexe, **kws)
+        assert_(s == 0)
+        assert_(o == '012')
+
+        s, o = exec_command.exec_command(
+                 '"%s" -c "import sys;sys.exit(15)"' % self.pyexe, **kws)
+        assert_(s == 15)
+        assert_(o == '')
+
+        s, o = exec_command.exec_command(
+                     '"%s" -c "print(\'Heipa\'")' % self.pyexe, **kws)
+        assert_(s == 0)
+        assert_(o == 'Heipa')
+
+    def check_execute_in(self, **kws):
+        with tempdir() as tmpdir:
+            fn = "file"
+            tmpfile = os.path.join(tmpdir, fn)
+            with open(tmpfile, 'w') as f:
+                f.write('Hello')
+
+            s, o = exec_command.exec_command(
+                 '"%s" -c "f = open(\'%s\', \'r\'); f.close()"' %
+                 (self.pyexe, fn), **kws)
+            assert_(s != 0)
+            assert_(o != '')
+            s, o = exec_command.exec_command(
+                     '"%s" -c "f = open(\'%s\', \'r\'); print(f.read()); '
+                     'f.close()"' % (self.pyexe, fn), execute_in=tmpdir, **kws)
+            assert_(s == 0)
+            assert_(o == 'Hello')
+
+    def test_basic(self):
+        with redirect_stdout(StringIO()):
+            with redirect_stderr(StringIO()):
+                with pytest.warns(DeprecationWarning):
+                    if os.name == "posix":
+                        self.check_posix(use_tee=0)
+                        self.check_posix(use_tee=1)
+                    elif os.name == "nt":
+                        self.check_nt(use_tee=0)
+                        self.check_nt(use_tee=1)
+                    self.check_execute_in(use_tee=0)
+                    self.check_execute_in(use_tee=1)

numpy/distutils/tests/test_fcompiler.py

@@ -0,0 +1,43 @@
+from numpy.testing import assert_
+import numpy.distutils.fcompiler
+
+customizable_flags = [
+    ('f77', 'F77FLAGS'),
+    ('f90', 'F90FLAGS'),
+    ('free', 'FREEFLAGS'),
+    ('arch', 'FARCH'),
+    ('debug', 'FDEBUG'),
+    ('flags', 'FFLAGS'),
+    ('linker_so', 'LDFLAGS'),
+]
+
+
+def test_fcompiler_flags(monkeypatch):
+    monkeypatch.setenv('NPY_DISTUTILS_APPEND_FLAGS', '0')
+    fc = numpy.distutils.fcompiler.new_fcompiler(compiler='none')
+    flag_vars = fc.flag_vars.clone(lambda *args, **kwargs: None)
+
+    for opt, envvar in customizable_flags:
+        new_flag = '-dummy-{}-flag'.format(opt)
+        prev_flags = getattr(flag_vars, opt)
+
+        monkeypatch.setenv(envvar, new_flag)
+        new_flags = getattr(flag_vars, opt)
+
+        monkeypatch.delenv(envvar)
+        assert_(new_flags == [new_flag])
+
+    monkeypatch.setenv('NPY_DISTUTILS_APPEND_FLAGS', '1')
+
+    for opt, envvar in customizable_flags:
+        new_flag = '-dummy-{}-flag'.format(opt)
+        prev_flags = getattr(flag_vars, opt)
+        monkeypatch.setenv(envvar, new_flag)
+        new_flags = getattr(flag_vars, opt)
+
+        monkeypatch.delenv(envvar)
+        if prev_flags is None:
+            assert_(new_flags == [new_flag])
+        else:
+            assert_(new_flags == prev_flags + [new_flag])
+

numpy/distutils/tests/test_fcompiler_gnu.py

@@ -0,0 +1,55 @@
+from numpy.testing import assert_
+
+import numpy.distutils.fcompiler
+
+g77_version_strings = [
+    ('GNU Fortran 0.5.25 20010319 (prerelease)', '0.5.25'),
+    ('GNU Fortran (GCC 3.2) 3.2 20020814 (release)', '3.2'),
+    ('GNU Fortran (GCC) 3.3.3 20040110 (prerelease) (Debian)', '3.3.3'),
+    ('GNU Fortran (GCC) 3.3.3 (Debian 20040401)', '3.3.3'),
+    ('GNU Fortran (GCC 3.2.2 20030222 (Red Hat Linux 3.2.2-5)) 3.2.2'
+       ' 20030222 (Red Hat Linux 3.2.2-5)', '3.2.2'),
+]
+
+gfortran_version_strings = [
+    ('GNU Fortran 95 (GCC 4.0.3 20051023 (prerelease) (Debian 4.0.2-3))',
+     '4.0.3'),
+    ('GNU Fortran 95 (GCC) 4.1.0', '4.1.0'),
+    ('GNU Fortran 95 (GCC) 4.2.0 20060218 (experimental)', '4.2.0'),
+    ('GNU Fortran (GCC) 4.3.0 20070316 (experimental)', '4.3.0'),
+    ('GNU Fortran (rubenvb-4.8.0) 4.8.0', '4.8.0'),
+    ('4.8.0', '4.8.0'),
+    ('4.0.3-7', '4.0.3'),
+    ("gfortran: warning: couldn't understand kern.osversion '14.1.0\n4.9.1",
+     '4.9.1'),
+    ("gfortran: warning: couldn't understand kern.osversion '14.1.0\n"
+     "gfortran: warning: yet another warning\n4.9.1",
+     '4.9.1'),
+    ('GNU Fortran (crosstool-NG 8a21ab48) 7.2.0', '7.2.0')
+]
+
+class TestG77Versions:
+    def test_g77_version(self):
+        fc = numpy.distutils.fcompiler.new_fcompiler(compiler='gnu')
+        for vs, version in g77_version_strings:
+            v = fc.version_match(vs)
+            assert_(v == version, (vs, v))
+
+    def test_not_g77(self):
+        fc = numpy.distutils.fcompiler.new_fcompiler(compiler='gnu')
+        for vs, _ in gfortran_version_strings:
+            v = fc.version_match(vs)
+            assert_(v is None, (vs, v))
+
+class TestGFortranVersions:
+    def test_gfortran_version(self):
+        fc = numpy.distutils.fcompiler.new_fcompiler(compiler='gnu95')
+        for vs, version in gfortran_version_strings:
+            v = fc.version_match(vs)
+            assert_(v == version, (vs, v))
+
+    def test_not_gfortran(self):
+        fc = numpy.distutils.fcompiler.new_fcompiler(compiler='gnu95')
+        for vs, _ in g77_version_strings:
+            v = fc.version_match(vs)
+            assert_(v is None, (vs, v))

numpy/distutils/tests/test_fcompiler_intel.py

@@ -0,0 +1,30 @@
+import numpy.distutils.fcompiler
+from numpy.testing import assert_
+
+
+intel_32bit_version_strings = [
+    ("Intel(R) Fortran Intel(R) 32-bit Compiler Professional for applications"
+     "running on Intel(R) 32, Version 11.1", '11.1'),
+]
+
+intel_64bit_version_strings = [
+    ("Intel(R) Fortran IA-64 Compiler Professional for applications"
+     "running on IA-64, Version 11.0", '11.0'),
+    ("Intel(R) Fortran Intel(R) 64 Compiler Professional for applications"
+     "running on Intel(R) 64, Version 11.1", '11.1')
+]
+
+class TestIntelFCompilerVersions:
+    def test_32bit_version(self):
+        fc = numpy.distutils.fcompiler.new_fcompiler(compiler='intel')
+        for vs, version in intel_32bit_version_strings:
+            v = fc.version_match(vs)
+            assert_(v == version)
+
+
+class TestIntelEM64TFCompilerVersions:
+    def test_64bit_version(self):
+        fc = numpy.distutils.fcompiler.new_fcompiler(compiler='intelem')
+        for vs, version in intel_64bit_version_strings:
+            v = fc.version_match(vs)
+            assert_(v == version)

numpy/distutils/tests/test_fcompiler_nagfor.py

@@ -0,0 +1,22 @@
+from numpy.testing import assert_
+import numpy.distutils.fcompiler
+
+nag_version_strings = [('nagfor', 'NAG Fortran Compiler Release '
+                        '6.2(Chiyoda) Build 6200', '6.2'),
+                       ('nagfor', 'NAG Fortran Compiler Release '
+                        '6.1(Tozai) Build 6136', '6.1'),
+                       ('nagfor', 'NAG Fortran Compiler Release '
+                        '6.0(Hibiya) Build 1021', '6.0'),
+                       ('nagfor', 'NAG Fortran Compiler Release '
+                        '5.3.2(971)', '5.3.2'),
+                       ('nag', 'NAGWare Fortran 95 compiler Release 5.1'
+                        '(347,355-367,375,380-383,389,394,399,401-402,407,'
+                        '431,435,437,446,459-460,463,472,494,496,503,508,'
+                        '511,517,529,555,557,565)', '5.1')]
+
+class TestNagFCompilerVersions:
+    def test_version_match(self):
+        for comp, vs, version in nag_version_strings:
+            fc = numpy.distutils.fcompiler.new_fcompiler(compiler=comp)
+            v = fc.version_match(vs)
+            assert_(v == version)

numpy/distutils/tests/test_from_template.py

@@ -0,0 +1,44 @@
+
+from numpy.distutils.from_template import process_str
+from numpy.testing import assert_equal
+
+
+pyf_src = """
+python module foo
+    <_rd=real,double precision>
+    interface
+        subroutine <s,d>foosub(tol)
+            <_rd>, intent(in,out) :: tol
+        end subroutine <s,d>foosub
+    end interface
+end python module foo
+"""
+
+expected_pyf = """
+python module foo
+    interface
+        subroutine sfoosub(tol)
+            real, intent(in,out) :: tol
+        end subroutine sfoosub
+        subroutine dfoosub(tol)
+            double precision, intent(in,out) :: tol
+        end subroutine dfoosub
+    end interface
+end python module foo
+"""
+
+
+def normalize_whitespace(s):
+    """
+    Remove leading and trailing whitespace, and convert internal
+    stretches of whitespace to a single space.
+    """
+    return ' '.join(s.split())
+
+
+def test_from_template():
+    """Regression test for gh-10712."""
+    pyf = process_str(pyf_src)
+    normalized_pyf = normalize_whitespace(pyf)
+    normalized_expected_pyf = normalize_whitespace(expected_pyf)
+    assert_equal(normalized_pyf, normalized_expected_pyf)

numpy/distutils/tests/test_log.py

@@ -0,0 +1,34 @@
+import io
+import re
+from contextlib import redirect_stdout
+
+import pytest
+
+from numpy.distutils import log
+
+
+def setup_module():
+    f = io.StringIO()  # changing verbosity also logs here, capture that
+    with redirect_stdout(f):
+        log.set_verbosity(2, force=True)  # i.e. DEBUG
+
+
+def teardown_module():
+    log.set_verbosity(0, force=True)  # the default
+
+
+r_ansi = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+
+@pytest.mark.parametrize("func_name", ["error", "warn", "info", "debug"])
+def test_log_prefix(func_name):
+    func = getattr(log, func_name)
+    msg = f"{func_name} message"
+    f = io.StringIO()
+    with redirect_stdout(f):
+        func(msg)
+    out = f.getvalue()
+    assert out  # sanity check
+    clean_out = r_ansi.sub("", out)
+    line = next(line for line in clean_out.splitlines())
+    assert line == f"{func_name.upper()}: {msg}"

numpy/distutils/tests/test_mingw32ccompiler.py

@@ -0,0 +1,47 @@
+import shutil
+import subprocess
+import sys
+import pytest
+import os
+import sysconfig
+
+from numpy.distutils import mingw32ccompiler
+
+
+@pytest.mark.skipif(sys.platform != 'win32', reason='win32 only test')
+@pytest.mark.skipif(not os.path.exists(os.path.join(sys.prefix, 'libs')),
+                    reason="test requires mingw library layout")
+@pytest.mark.skipif(sysconfig.get_platform() == 'win-arm64', reason='mingw GNU objdump does not understand arm64 binary format yet')
+def test_build_import():
+    '''Test the mingw32ccompiler.build_import_library, which builds a
+    `python.a` from the MSVC `python.lib`
+    '''
+
+    # make sure `nm.exe` exists and supports the current python version. This
+    # can get mixed up when the PATH has a 64-bit nm but the python is 32-bit
+    try:
+        out = subprocess.check_output(['nm.exe', '--help'])
+    except FileNotFoundError:
+        pytest.skip("'nm.exe' not on path, is mingw installed?")
+    supported = out[out.find(b'supported targets:'):]
+    if sys.maxsize < 2**32:
+        if b'pe-i386' not in supported:
+            raise ValueError("'nm.exe' found but it does not support 32-bit "
+                             "dlls when using 32-bit python. Supported "
+                             "formats: '%s'" % supported)
+    elif b'pe-x86-64' not in supported:
+        raise ValueError("'nm.exe' found but it does not support 64-bit "
+                         "dlls when using 64-bit python. Supported "
+                         "formats: '%s'" % supported)
+    # Hide the import library to force a build
+    has_import_lib, fullpath = mingw32ccompiler._check_for_import_lib()
+    if has_import_lib: 
+        shutil.move(fullpath, fullpath + '.bak')
+
+    try: 
+        # Whew, now we can actually test the function
+        mingw32ccompiler.build_import_library()
+
+    finally:
+        if has_import_lib:
+            shutil.move(fullpath + '.bak', fullpath)