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_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_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 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 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
