def test_unsupported_platform(mocker): mocker.patch('platform.system', return_value='bogus') failed = False message = "" try: get_platform() except RuntimeError as e: failed = True message = str(e) assert failed assert "Unsupported platform: bogus." in message
def test_invalid_generator(mocker, capfd): platform = get_platform() mocker.patch.object(type(platform), 'default_generators', new_callable=mocker.PropertyMock, return_value=[CMakeGenerator('Invalid')]) mocker.patch('skbuild.cmaker.get_platform', return_value=platform) with push_dir(), push_env(CMAKE_GENERATOR=None): @project_setup_py_test("hello", ["build"]) def should_fail(): pass failed = False message = "" try: should_fail() except SystemExit as e: failed = isinstance(e.code, SKBuildError) message = str(e) _, err = capfd.readouterr() assert "CMake Error: Could not create named generator Invalid" in err assert failed assert "scikit-build could not get a working generator for your system." \ " Aborting build." in message
def test_invalid_generator(mocker, capfd): platform = get_platform() mocker.patch.object(type(platform), 'default_generators', new_callable=mocker.PropertyMock, return_value=[CMakeGenerator('Invalid')]) mocker.patch('skbuild.cmaker.get_platform', return_value=platform) with push_dir(), push_env(CMAKE_GENERATOR=None): @project_setup_py_test("hello-no-language", ["build"]) def should_fail(): pass failed = False message = "" try: should_fail() except SystemExit as e: failed = isinstance(e.code, SKBuildError) message = str(e) _, err = capfd.readouterr() assert "CMake Error: Could not create named generator Invalid" in err assert failed assert "scikit-build could not get a working generator for your system." \ " Aborting build." in message
def test_generator_selection(): version = sys.version_info env_generator = os.environ.get("CMAKE_GENERATOR") this_platform = platform.system().lower() get_best_generator = get_platform().get_best_generator arch = platform.architecture()[0] if env_generator: assert (get_best_generator(env_generator).name == env_generator) if this_platform == "windows": # assert that we are running a supported version of python py_27_32 = ((version.major == 2 and version.minor >= 7) or (version.major == 3 and version.minor <= 2)) py_33_34 = (version.major == 3 and (3 <= version.minor <= 4)) py_35 = (version.major == 3 and version.minor >= 5) assert (len(tuple(filter(bool, (py_27_32, py_33_34, py_35)))) == 1) vs_ide_vcvars_path_pattern = \ "C:/Program Files (x86)/" \ "Microsoft Visual Studio %.1f/VC/vcvarsall.bat" # As of Dec 2016, this is available only for VS 9.0 vs_for_python_vcvars_path_pattern = \ "~/AppData/Local/Programs/Common/" \ "Microsoft/Visual C++ for Python/%.1f/vcvarsall.bat" if py_27_32: generator = "Visual Studio 9 2008" vs_version = 9 elif py_33_34: generator = "Visual Studio 10 2010" vs_version = 10 else: generator = "Visual Studio 14 2015" vs_version = 14 generator += (" Win64" if arch == "64bit" else "") vs_ide_vcvars_path = vs_ide_vcvars_path_pattern % vs_version vs_for_python_vcvars_path = os.path.expanduser( vs_for_python_vcvars_path_pattern % vs_version) # If environment exists and ninja is found, update the # expected generator if (os.path.exists(vs_for_python_vcvars_path) or os.path.exists(vs_ide_vcvars_path)) and which("ninja.exe"): generator = "Ninja" assert (get_best_generator().name == generator) elif this_platform in ["darwin", "linux"]: generator = "Unix Makefiles" if which("ninja"): generator = "Ninja" assert get_best_generator().name == generator
def test_cached_generator(): def is_configured_generator(generator): env = generator.env env_lib = env.get('LIB', '') return 'Visual Studio' in env_lib or 'Visual C++' in env_lib platform = get_platform() ninja_generators = platform.get_generators('Ninja') assert any(is_configured_generator(g) for g in ninja_generators)
def test_known_platform(supported_platform, mocker): mocker.patch('platform.system', return_value=supported_platform) platforms = { 'freebsd': 'BSD', 'linux': 'Linux', 'darwin': 'OSX', 'windows': 'Windows' } expected_platform_classname = "%sPlatform" % platforms[supported_platform] assert get_platform().__class__.__name__ == expected_platform_classname
def test_distribution_is_pure(distribution_type, tmpdir): skbuild_setup_kwargs = {} if distribution_type == 'unknown': is_pure = False elif distribution_type == 'py_modules': is_pure = True hello_py = tmpdir.join("hello.py") hello_py.write("") skbuild_setup_kwargs["py_modules"] = ["hello"] elif distribution_type == 'packages': is_pure = True init_py = tmpdir.mkdir("hello").join("__init__.py") init_py.write("") skbuild_setup_kwargs["packages"] = ["hello"] elif distribution_type == 'skbuild': is_pure = False cmakelists_txt = tmpdir.join("CMakeLists.txt") cmakelists_txt.write( """ cmake_minimum_required(VERSION 3.5.0) project(test NONE) install(CODE "execute_process( COMMAND \${CMAKE_COMMAND} -E sleep 0)") """ ) else: raise Exception( "Unknown distribution_type: {}".format(distribution_type)) platform = get_platform() original_write_test_cmakelist = platform.write_test_cmakelist def write_test_cmakelist_no_languages(_self, _languages): original_write_test_cmakelist([]) with patch.object(type(platform), 'write_test_cmakelist', new=write_test_cmakelist_no_languages): with push_dir(str(tmpdir)), push_argv(["setup.py", "build"]): distribution = skbuild_setup( name="test", version="0.0.1", description="test object returned by setup function", author="The scikit-build team", license="MIT", **skbuild_setup_kwargs ) assert issubclass(distribution.__class__, (distutils_Distribution, setuptool_Distribution)) assert is_pure == distribution.is_pure()
def execute_setup_py(project_dir, setup_args, disable_languages_test=False): """Context manager executing ``setup.py`` with the given arguments. It yields after changing the current working directory to ``project_dir``. """ # See https://stackoverflow.com/questions/9160227/dir-util-copy-tree-fails-after-shutil-rmtree distutils.dir_util._path_created = {} # Clear _PYTHON_HOST_PLATFORM to ensure value sets in skbuild.setuptools_wrap.setup() does not # influence other tests. if '_PYTHON_HOST_PLATFORM' in os.environ: del os.environ['_PYTHON_HOST_PLATFORM'] with push_dir(str(project_dir)), push_argv(["setup.py"] + setup_args), prepend_sys_path( [str(project_dir)]): # Restore master working set that is reset following call to "python setup.py test" # See function "project_on_sys_path()" in setuptools.command.test pkg_resources._initialize_master_working_set() with open("setup.py", "r") as fp: setup_code = compile(fp.read(), "setup.py", mode="exec") if setup_code is not None: if disable_languages_test: platform = get_platform() original_write_test_cmakelist = platform.write_test_cmakelist def write_test_cmakelist_no_languages(_self, _languages): original_write_test_cmakelist([]) with patch.object(type(platform), 'write_test_cmakelist', new=write_test_cmakelist_no_languages): six.exec_(setup_code) else: six.exec_(setup_code) yield
def test_first_invalid_generator(mocker, capfd): platform = get_platform() default_generators = [CMakeGenerator('Invalid')] default_generators.extend(platform.default_generators) mocker.patch.object(type(platform), 'default_generators', new_callable=mocker.PropertyMock, return_value=default_generators) mocker.patch('skbuild.cmaker.get_platform', return_value=platform) with push_dir(), push_env(CMAKE_GENERATOR=None): @project_setup_py_test("hello-no-language", ["build"]) def run_build(): pass run_build() _, err = capfd.readouterr() assert "CMake Error: Could not create named generator Invalid" in err
def execute_setup_py(project_dir, setup_args, disable_languages_test=False): """Context manager executing ``setup.py`` with the given arguments. It yields after changing the current working directory to ``project_dir``. """ # See https://stackoverflow.com/questions/9160227/dir-util-copy-tree-fails-after-shutil-rmtree distutils.dir_util._path_created = {} # Clear _PYTHON_HOST_PLATFORM to ensure value sets in skbuild.setuptools_wrap.setup() does not # influence other tests. if '_PYTHON_HOST_PLATFORM' in os.environ: del os.environ['_PYTHON_HOST_PLATFORM'] with push_dir(str(project_dir)), push_argv(["setup.py"] + setup_args), prepend_sys_path([str(project_dir)]): # Restore master working set that is reset following call to "python setup.py test" # See function "project_on_sys_path()" in setuptools.command.test pkg_resources._initialize_master_working_set() with open("setup.py", "r") as fp: setup_code = compile(fp.read(), "setup.py", mode="exec") if setup_code is not None: if disable_languages_test: platform = get_platform() original_write_test_cmakelist = platform.write_test_cmakelist def write_test_cmakelist_no_languages(_self, _languages): original_write_test_cmakelist([]) with patch.object(type(platform), 'write_test_cmakelist', new=write_test_cmakelist_no_languages): six.exec_(setup_code) else: six.exec_(setup_code) yield
def test_generator_selection(): version = sys.version_info env_generator = os.environ.get("CMAKE_GENERATOR") this_platform = platform.system().lower() get_best_generator = get_platform().get_best_generator arch = platform.architecture() if env_generator: assert(get_best_generator(env_generator) == env_generator) if this_platform == "windows": # assert that we are running a supported version of python py_27_32 = ( (version.major == 2 and version.minor >= 7) or (version.major == 3 and version.minor <= 2) ) py_33_34 = ( version.major == 3 and ( 3 <= version.minor <= 4 ) ) py_35 = ( version.major == 3 and version.minor >= 5 ) assert(len(tuple(filter(bool, (py_27_32, py_33_34, py_35)))) == 1) generator = ( "Visual Studio 9 2008" if py_27_32 else "Visual Studio 10 2010" if py_33_34 else "Visual Studio 14 2015" ) + ( "Win64" if arch == "x64" else "ARM" if arch == "ARM" else "" ) assert(get_best_generator() == generator)
def execute_setup_py(project_dir, setup_args, disable_languages_test=False): """Context manager executing ``setup.py`` with the given arguments. It yields after changing the current working directory to ``project_dir``. """ # See https://stackoverflow.com/questions/9160227/dir-util-copy-tree-fails-after-shutil-rmtree distutils.dir_util._path_created = {} with push_dir(str(project_dir)), push_argv(["setup.py"] + setup_args), prepend_sys_path( [str(project_dir)]): with open("setup.py", "r") as fp: setup_code = compile(fp.read(), "setup.py", mode="exec") if setup_code is not None: if disable_languages_test: platform = get_platform() original_write_test_cmakelist = platform.write_test_cmakelist def write_test_cmakelist_no_languages(_self, _languages): original_write_test_cmakelist([]) with patch.object(type(platform), 'write_test_cmakelist', new=write_test_cmakelist_no_languages): six.exec_(setup_code) else: six.exec_(setup_code) yield
Tests for platforms, to verify that CMake correctly does a test compilation. """ import os import pytest from skbuild.platform_specifics import get_platform from skbuild.utils import mkdir_p # XXX This should probably be a constant imported from skbuild.constants test_folder = "_cmake_test_compile" # platform is shared across each test. It's a platform-specific object # that defines default CMake generator strings. platform = get_platform() def test_platform_has_entries(): assert (len(platform.default_generators) > 0) def test_write_compiler_test_file(): # write the file that CMake will use to test compile (empty list indicates # we're testing no languages.) platform.write_test_cmakelist([]) try: # verify that the test file exists (it's not valid, because it has no # languages) assert (os.path.exists(os.path.join(test_folder, "CMakeLists.txt"))) except:
@project_setup_py_test(("samples", "hello"), ["build"], clear_cache=True) def run(): pass # Check that a project can be build twice in a row # See issue scikit-build#120 run() run() @pytest.mark.parametrize("generator_args", [ ["-G", "invalid"], ["--", "-G", "invalid"], ["-G", get_platform().default_generators[0]], ["--", "-G", get_platform().default_generators[0]], ]) def test_hello_builds_with_generator(generator_args): with push_dir(): build_args = ["build"] build_args.extend(generator_args) @project_setup_py_test(("samples", "hello"), build_args, clear_cache=True) def run(): pass failed = False message = ""
def test_generator_selection(): version = sys.version_info env_generator = os.environ.get("CMAKE_GENERATOR") this_platform = platform.system().lower() get_best_generator = get_platform().get_best_generator arch = platform.architecture()[0] if env_generator: assert(get_best_generator(env_generator).name == env_generator) if this_platform == "windows": # assert that we are running a supported version of python py_27_32 = ( (version.major == 2 and version.minor >= 7) or (version.major == 3 and version.minor <= 2) ) py_33_34 = ( version.major == 3 and ( 3 <= version.minor <= 4 ) ) py_35 = ( version.major == 3 and version.minor >= 5 ) assert(len(tuple(filter(bool, (py_27_32, py_33_34, py_35)))) == 1) vs_ide_vcvars_path_pattern = \ "C:/Program Files (x86)/" \ "Microsoft Visual Studio %.1f/VC/vcvarsall.bat" # As of Dec 2016, this is available only for VS 9.0 vs_for_python_vcvars_path_pattern = \ "~/AppData/Local/Programs/Common/" \ "Microsoft/Visual C++ for Python/%.1f/vcvarsall.bat" if py_27_32: vs_generator = "Visual Studio 9 2008" vs_version = 9 elif py_33_34: vs_generator = "Visual Studio 10 2010" vs_version = 10 else: vs_generator = "Visual Studio 14 2015" vs_version = 14 vs_generator += (" Win64" if arch == "64bit" else "") vs_ide_vcvars_path = vs_ide_vcvars_path_pattern % vs_version vs_for_python_vcvars_path = os.path.expanduser( vs_for_python_vcvars_path_pattern % vs_version) generator = None # If environment exists, update the expected generator if ( os.path.exists(vs_for_python_vcvars_path) or os.path.exists(vs_ide_vcvars_path) ) and which("ninja.exe"): generator = "Ninja" elif os.path.exists(vs_ide_vcvars_path): generator = vs_generator elif os.path.exists(vs_for_python_vcvars_path): generator = "NMake Makefiles" assert (get_best_generator().name == generator) elif this_platform in ["darwin", "linux"]: generator = "Unix Makefiles" if which("ninja"): generator = "Ninja" assert get_best_generator().name == generator
""" import os import sys import platform import pytest from skbuild.platform_specifics import get_platform from skbuild.utils import mkdir_p # XXX This should probably be a constant imported from skbuild.constants test_folder = "_cmake_test_compile" # skbuild_platform is shared across each test. It's a platform-specific object # that defines default CMake generator strings. skbuild_platform = get_platform() def test_platform_has_entries(): assert(len(skbuild_platform.default_generators) > 0) def test_write_compiler_test_file(): # write the file that CMake will use to test compile (empty list indicates # we're testing no languages.) skbuild_platform.write_test_cmakelist([]) try: # verify that the test file exists (it's not valid, because it has no # languages) assert(os.path.exists(os.path.join(test_folder, "CMakeLists.txt"))) finally:
def test_generator_selection(): version = sys.version_info env_generator = os.environ.get("CMAKE_GENERATOR") this_platform = platform.system().lower() get_best_generator = get_platform().get_best_generator arch = platform.architecture()[0] if env_generator: assert (get_best_generator(env_generator).name == env_generator) if this_platform == "windows": # assert that we are running a supported version of python py_27_32 = ((version.major == 2 and version.minor >= 7) or (version.major == 3 and version.minor <= 2)) py_33_34 = (version.major == 3 and (3 <= version.minor <= 4)) py_35 = (version.major == 3 and version.minor >= 5) assert (len(tuple(filter(bool, (py_27_32, py_33_34, py_35)))) == 1) # Expected Visual Studio version if py_27_32: vs_generator = "Visual Studio 9 2008" vs_version = 9 elif py_33_34: vs_generator = "Visual Studio 10 2010" vs_version = 10 else: vs_generator = "Visual Studio 14 2015" vs_version = 14 vs_generator += (" Win64" if arch == "64bit" else "") has_vs_2017 = find_visual_studio(vs_version=VS_YEAR_TO_VERSION["2017"]) has_vs_2019 = find_visual_studio(vs_version=VS_YEAR_TO_VERSION["2019"]) # Apply to VS <= 14 (2015) has_vs_ide_vcvars = any([ os.path.exists(path_pattern % vs_version) for path_pattern in [ "C:/Program Files (x86)/Microsoft Visual Studio %.1f/VC/vcvarsall.bat" ] ]) # As of Dec 2016, this is available only for VS 9.0 has_vs_for_python_vcvars = any([ os.path.exists(os.path.expanduser(path_pattern % vs_version)) for path_pattern in [ "~/AppData/Local/Programs/Common/Microsoft/Visual C++ for Python/%.1f/vcvarsall.bat", "C:/Program Files (x86)/Common Files/Microsoft/Visual C++ for Python/%.1f/vcvarsall.bat" ] ]) generator = None # If environment exists, update the expected generator if (has_vs_for_python_vcvars or has_vs_ide_vcvars) and which("ninja.exe"): generator = "Ninja" elif has_vs_2017 or has_vs_2019: # ninja is provided by the CMake extension bundled with Visual Studio 2017 # C:/Program Files (x86)/Microsoft Visual Studio/2017/Professional/Common7/IDE/CommonExtensions/Microsoft/CMake/Ninja/ninja.exe # noqa: E501 generator = "Ninja" elif has_vs_ide_vcvars or has_vs_2017: generator = vs_generator elif has_vs_for_python_vcvars: generator = "NMake Makefiles" assert (get_best_generator().name == generator) elif this_platform in ["darwin", "linux"]: generator = "Unix Makefiles" if which("ninja"): generator = "Ninja" assert get_best_generator().name == generator
def test_cached_generator(): platform = get_platform() generator = platform.get_generator('Ninja') env = generator.env assert 'Visual Studio' in env['LIB'] or 'Visual C++' in env['LIB']
Tests for platforms, to verify that CMake correctly does a test compilation. """ import os import platform import pytest from skbuild.platform_specifics import get_platform from skbuild.utils import mkdir_p # XXX This should probably be a constant imported from skbuild.constants test_folder = "_cmake_test_compile" # skbuild_platform is shared across each test. It's a platform-specific object # that defines default CMake generator strings. skbuild_platform = get_platform() def test_platform_has_entries(): assert(len(skbuild_platform.default_generators) > 0) def test_write_compiler_test_file(): # write the file that CMake will use to test compile (empty list indicates # we're testing no languages.) skbuild_platform.write_test_cmakelist([]) try: # verify that the test file exists (it's not valid, because it has no # languages) assert(os.path.exists(os.path.join(test_folder, "CMakeLists.txt"))) finally:
#!/usr/bin/env python # -*- coding: utf-8 -*- """test_platform ---------------------------------- Tests for platforms, to verify that CMake correctly does a test compilation. """ import os from skbuild.platform_specifics import get_platform # platform is shared across each test. It's a platform-specific object # that defines default CMake generator strings. platform = get_platform() def test_platform_has_entries(): assert(len(platform.default_generators) > 0) def test_write_compiler_test_file(): # write the file that CMake will use to test compile (empty list indicates # we're testing no languages.) platform.write_test_cmakelist([]) try: # verify that the test file exists (it's not valid, because it has no # languages) assert(os.path.exists("cmake_test_compile/CMakeLists.txt")) except:
def test_generator_selection(): version = sys.version_info env_generator = os.environ.get("CMAKE_GENERATOR") this_platform = platform.system().lower() get_best_generator = get_platform().get_best_generator arch = platform.architecture()[0] if env_generator: assert(get_best_generator(env_generator).name == env_generator) if this_platform == "windows": # assert that we are running a supported version of python py_27_32 = ( (version.major == 2 and version.minor >= 7) or (version.major == 3 and version.minor <= 2) ) py_33_34 = ( version.major == 3 and ( 3 <= version.minor <= 4 ) ) py_35 = ( version.major == 3 and version.minor >= 5 ) assert(len(tuple(filter(bool, (py_27_32, py_33_34, py_35)))) == 1) # Expected Visual Studio version if py_27_32: vs_generator = "Visual Studio 9 2008" vs_version = 9 elif py_33_34: vs_generator = "Visual Studio 10 2010" vs_version = 10 else: vs_generator = "Visual Studio 14 2015" vs_version = 14 vs_generator += (" Win64" if arch == "64bit" else "") has_vs_2017 = find_visual_studio(vs_version=VS_YEAR_TO_VERSION["2017"]) # Apply to VS <= 14 (2015) has_vs_ide_vcvars = any([ os.path.exists(path_pattern % vs_version) for path_pattern in [ "C:/Program Files (x86)/Microsoft Visual Studio %.1f/VC/vcvarsall.bat" ] ]) # As of Dec 2016, this is available only for VS 9.0 has_vs_for_python_vcvars = any([ os.path.exists(os.path.expanduser(path_pattern % vs_version)) for path_pattern in [ "~/AppData/Local/Programs/Common/Microsoft/Visual C++ for Python/%.1f/vcvarsall.bat", "C:/Program Files (x86)/Common Files/Microsoft/Visual C++ for Python/%.1f/vcvarsall.bat" ] ]) generator = None # If environment exists, update the expected generator if ( has_vs_for_python_vcvars or has_vs_ide_vcvars ) and which("ninja.exe"): generator = "Ninja" elif has_vs_2017: # ninja is provided by the CMake extension bundled with Visual Studio 2017 # C:/Program Files (x86)/Microsoft Visual Studio/2017/Professional/Common7/IDE/CommonExtensions/Microsoft/CMake/Ninja/ninja.exe # noqa: E501 generator = "Ninja" elif has_vs_ide_vcvars or has_vs_2017: generator = vs_generator elif has_vs_for_python_vcvars: generator = "NMake Makefiles" assert (get_best_generator().name == generator) elif this_platform in ["darwin", "linux"]: generator = "Unix Makefiles" if which("ninja"): generator = "Ninja" assert get_best_generator().name == generator