def test_clean_sh_path(self):
if platform.system() != "Windows":
return
os.environ["PATH"] = os.environ.get("PATH", "") + os.pathsep + self.tempdir
save(os.path.join(self.tempdir, "sh.exe"), "Fake sh")
conanfile = ConanFileMock()
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "12"
settings.arch = "x86"
conanfile.settings = settings
cmake = CMake(conanfile)
cmake.configure()
self.assertIn(self.tempdir, conanfile.path)
cmake.generator = "MinGW Makefiles"
cmake.configure()
self.assertNotIn(self.tempdir, conanfile.path)
# Automatic gcc
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "gcc"
settings.compiler.version = "5.4"
settings.arch = "x86"
conanfile.settings = settings
cmake = CMake(conanfile)
cmake.configure()
self.assertNotIn(self.tempdir, conanfile.path)
def test_none__sub_subsetting(self):
yml = """os:
None:
subsystem: [None, cygwin]
Windows:
"""
with self.assertRaisesRegexp(ConanException,
"settings.yml: None setting can't have subsettings"):
Settings.loads(yml)
def test_os_split(self):
settings = Settings.loads("""os:
Windows:
Linux:
Macos:
version: [1, 2]
Android:
""")
other_settings = Settings.loads("os: [Windows, Linux]")
settings.os = "Windows"
other_settings.os = "Windows"
self.assertEqual(settings.values.sha, other_settings.values.sha)
def settings(self):
"""Returns {setting: [value, ...]} defining all the possible
settings and their values"""
if not self._settings:
if not os.path.exists(self.settings_path):
save(self.settings_path, default_settings_yml)
settings = Settings.loads(default_settings_yml)
else:
content = load(self.settings_path)
settings = Settings.loads(content)
settings.values = self.conan_config.settings_defaults
self._settings = settings
return self._settings
def settings(self):
"""Returns {setting: [value, ...]} defining all the possible
settings and their values"""
if not self._settings:
# TODO: Read default environment settings
if not os.path.exists(self.settings_path):
save(self.settings_path, normalize(default_settings_yml))
settings = Settings.loads(default_settings_yml)
else:
content = load(self.settings_path)
settings = Settings.loads(content)
self.conan_config.settings_defaults(settings)
self._settings = settings
return self._settings
def test_none_value(self):
yml = "os: [None, Windows]"
settings = Settings.loads(yml)
# Same sha as if settings were empty
self.assertEqual(settings.values.sha, Settings.loads("").values.sha)
settings.validate()
self.assertTrue(settings.os == None)
self.assertEqual("", settings.values.dumps())
settings.os = "None"
self.assertEqual(settings.values.sha, Settings.loads("").values.sha)
settings.validate()
self.assertTrue(settings.os == "None")
self.assertEqual("os=None", settings.values.dumps())
settings.os = "Windows"
self.assertTrue(settings.os == "Windows")
self.assertEqual("os=Windows", settings.values.dumps())
def test_invalid(self):
if platform.system() != "Windows":
return
fake_settings_yml = """
os:
WindowsStore:
version: ["666"]
arch: [x86]
compiler:
Visual Studio:
runtime: [MD, MT, MTd, MDd]
version: ["8", "9", "10", "11", "12", "14", "15"]
build_type: [None, Debug, Release]
"""
settings = Settings.loads(fake_settings_yml)
settings.compiler = 'Visual Studio'
settings.compiler.version = '14'
settings.arch = 'x86'
settings.os = 'WindowsStore'
settings.os.version = '666'
with self.assertRaises(ConanException):
tools.vcvars_command(settings)
def loads_default_test(self):
settings = Settings.loads(default_settings_yml)
settings.compiler = "Visual Studio"
settings.compiler.version = "12"
settings.arch = "x86"
cmake = CMake(settings)
self.assertEqual('-G "Visual Studio 12" -DCONAN_COMPILER="Visual Studio" '
'-DCONAN_COMPILER_VERSION="12" -Wno-dev', cmake.command_line)
self.assertEqual('', cmake.build_config)
settings.build_type = "Debug"
self.assertEqual('-G "Visual Studio 12" -DCONAN_COMPILER="Visual Studio" '
'-DCONAN_COMPILER_VERSION="12" -Wno-dev', cmake.command_line)
self.assertEqual('--config Debug', cmake.build_config)
settings.arch = "x86_64"
self.assertEqual('-G "Visual Studio 12 Win64" -DCONAN_COMPILER="Visual Studio" '
'-DCONAN_COMPILER_VERSION="12" -Wno-dev', cmake.command_line)
settings.os = "Windows"
settings.compiler = "gcc"
settings.compiler.version = "4.8"
self.assertEqual('-G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Debug -DCONAN_COMPILER="gcc" '
'-DCONAN_COMPILER_VERSION="4.8" -Wno-dev', cmake.command_line)
settings.os = "Linux"
settings.arch = "x86"
self.assertEqual('-G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug -DCONAN_COMPILER="gcc" '
'-DCONAN_COMPILER_VERSION="4.8" -DCONAN_CXX_FLAGS=-m32 '
'-DCONAN_SHARED_LINK_FLAGS=-m32 -DCONAN_C_FLAGS=-m32 -Wno-dev',
cmake.command_line)
def test_deprecated_behaviour(self):
""""Remove when deprecate the old settings parameter to CMake and conanfile to configure/build/test"""
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "12"
settings.arch = "x86"
settings.os = "Windows"
dot_dir = "." if sys.platform == 'win32' else "'.'"
cross = "-DCMAKE_SYSTEM_NAME=\"Windows\" " if platform.system() != "Windows" else ""
conan_file = ConanFileMock()
conan_file.settings = settings
cmake = CMake(settings)
cmake.configure(conan_file)
cores = '-DCONAN_CXX_FLAGS="/MP{0}" -DCONAN_C_FLAGS="/MP{0}" '.format(tools.cpu_count())
self.assertEqual('cd {0} && cmake -G "Visual Studio 12 2013" {1}-DCONAN_EXPORTED="1" '
'-DCONAN_COMPILER="Visual Studio" -DCONAN_COMPILER_VERSION="12" {2}'
'-Wno-dev {0}'.format(dot_dir, cross, cores),
conan_file.command)
cmake.build(conan_file)
self.assertEqual('cmake --build %s' % dot_dir, conan_file.command)
cmake.test()
self.assertEqual('cmake --build %s %s' % (dot_dir, CMakeTest.scape('--target RUN_TESTS')), conan_file.command)
def test_shared(self):
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "12"
settings.arch = "x86"
settings.os = "Windows"
conan_file = ConanFileMock(shared=True)
conan_file.settings = settings
cmake = CMake(conan_file)
self.assertEquals(cmake.definitions["BUILD_SHARED_LIBS"], "ON")
conan_file = ConanFileMock(shared=False)
conan_file.settings = settings
cmake = CMake(conan_file)
self.assertEquals(cmake.definitions["BUILD_SHARED_LIBS"], "OFF")
conan_file = ConanFileMock(shared=None)
conan_file.settings = settings
cmake = CMake(conan_file)
self.assertNotIn("BUILD_SHARED_LIBS", cmake.definitions)
def vcvars_constrained_test(self):
text = """os: [Windows]
compiler:
Visual Studio:
version: ["14"]
"""
settings = Settings.loads(text)
settings.os = "Windows"
settings.compiler = "Visual Studio"
with self.assertRaisesRegexp(ConanException,
"compiler.version setting required for vcvars not defined"):
tools.vcvars_command(settings)
new_out = StringIO()
tools.set_global_instances(ConanOutput(new_out), None)
settings.compiler.version = "14"
with tools.environment_append({"vs140comntools": "path/to/fake"}):
tools.vcvars_command(settings)
with tools.environment_append({"VisualStudioVersion": "12"}):
with self.assertRaisesRegexp(ConanException,
"Error, Visual environment already set to 12"):
tools.vcvars_command(settings)
with tools.environment_append({"VisualStudioVersion": "12"}):
# Not raising
tools.vcvars_command(settings, force=True)
def test_arch_override(self):
if platform.system() != "Windows":
return
settings = Settings.loads(default_settings_yml)
settings.compiler = 'Visual Studio'
settings.compiler.version = '14'
settings.arch = 'mips64'
command = tools.vcvars_command(settings, arch='x86')
self.assertIn('vcvarsall.bat', command)
self.assertIn('x86', command)
command = tools.vcvars_command(settings, arch='x86_64')
self.assertIn('vcvarsall.bat', command)
self.assertIn('amd64', command)
command = tools.vcvars_command(settings, arch='armv7')
self.assertIn('vcvarsall.bat', command)
self.assertNotIn('arm64', command)
self.assertIn('arm', command)
command = tools.vcvars_command(settings, arch='armv8')
self.assertIn('vcvarsall.bat', command)
self.assertIn('arm64', command)
with self.assertRaises(ConanException):
tools.vcvars_command(settings, arch='mips')
def test_simple(self):
settings = Settings.loads(default_settings_yml)
settings.compiler = 'clang'
settings.compiler.version = '5.0'
settings.arch = 'x86'
settings.os = 'Windows'
command = tools.vcvars_command(settings)
self.assertIn('vcvarsall.bat', command)
self.assertIn('x86', command)
def test_simple(self):
settings = Settings.loads(get_default_settings_yml())
settings.compiler = 'clang'
settings.compiler.version = '5.0'
settings.arch = 'x86'
settings.os = 'Windows'
command = vcvars_command(settings, output=self.output)
self.assertIn('vcvarsall.bat', command)
self.assertIn('x86', command)
def test_no_msvc(self):
settings = Settings.loads(get_default_settings_yml())
settings.compiler = 'clang'
settings.arch = 'x86_64'
settings.os = 'Windows'
with mock.patch('conans.client.tools.win.latest_vs_version_installed',
mock.MagicMock(return_value=None)):
with self.assertRaises(ConanException):
vcvars_command(settings, output=self.output)
def build_type_ovewrite_test(self):
settings = Settings.loads(default_settings_yml)
settings.os = "Linux"
settings.compiler = "gcc"
settings.compiler.version = "6.3"
settings.arch = "x86"
settings.build_type = "Release"
conan_file = ConanFileMock()
conan_file.settings = settings
cmake = CMake(conan_file)
cmake.build_type = "Debug"
self.assertIn(
'WARN: Set CMake build type "Debug" is different than the '
'settings build_type "Release"', conan_file.output)
self.assertEquals(cmake.build_type, "Debug")
self.assertIn('-DCMAKE_BUILD_TYPE="Debug"', cmake.command_line)
conan_file = ConanFileMock()
conan_file.settings = settings
cmake = CMake(conan_file)
self.assertNotIn('WARN: Set CMake build type ', conan_file.output)
self.assertEquals(cmake.build_type, "Release")
# Now with visual, (multiconfig)
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "15"
settings.arch = "x86"
settings.build_type = "Release"
conan_file = ConanFileMock()
conan_file.settings = settings
cmake = CMake(conan_file)
cmake.build_type = "Debug"
self.assertIn(
'WARN: Set CMake build type "Debug" is different than the '
'settings build_type "Release"', conan_file.output)
self.assertEquals(cmake.build_type, "Debug")
self.assertNotIn('-DCMAKE_BUILD_TYPE="Debug"', cmake.command_line)
self.assertIn("--config Debug", cmake.build_config)
cmake = CMake(conan_file)
cmake.build_type = "Release"
self.assertIn("--config Release", cmake.build_config)
def test_get_safe(self):
yml = "os: [None, Windows]"
settings = Settings.loads(yml)
settings.os = "Windows"
self.assertEqual(settings.os, "Windows")
self.assertEqual(settings.get_safe("compiler.version"), None)
self.assertEqual(settings.get_safe("build_type"), None)
self.assertEqual("Release", settings.get_safe("build_type", "Release"))
self.assertEqual(False, settings.get_safe("build_type", False))
self.assertEqual("Windows", settings.get_safe("os", "Linux"))
def test_windows_linux_remove(self):
yml = "os: [Windows, Linux]"
settings = Settings.loads(yml)
settings.os = "Windows"
settings.os.remove("Linux")
# removing a definition which is not contained shall not raise an exception
settings.os.remove("invalid")
settings.os.remove("ANY")
with six.assertRaisesRegex(self, ConanException, "Invalid setting 'Windows'"):
settings.os.remove("Windows")
def test_gcc(self):
settings = Settings.loads(get_default_settings_yml())
settings.os = "Linux"
settings.compiler = "gcc"
settings.compiler.version = "6.3"
settings.arch = "x86"
settings.build_type = "Release"
settings.cppstd = "gnu17"
conan_file = self._get_conanfile(settings)
gcc = GCCGenerator(conan_file)
self.assertEqual(
'-Dmydefine1 -I/root/include -I/root/path/to/include1'
' cxx_flag1 c_flag1 -m32 -O3 -s -DNDEBUG'
' -Wl,-rpath,"/root/lib" -Wl,-rpath,"/root/path/to/lib1"'
' -L/root/lib -L/root/path/to/lib1 -lmylib'
' -F /root/Frameworks -std=gnu++17', gcc.content)
settings.arch = "x86_64"
settings.build_type = "Debug"
settings.compiler.libcxx = "libstdc++11"
gcc = GCCGenerator(conan_file)
self.assertEqual(
'-Dmydefine1 -I/root/include -I/root/path/to/include1'
' cxx_flag1 c_flag1 -m64 -g'
' -Wl,-rpath,"/root/lib" -Wl,-rpath,"/root/path/to/lib1"'
' -L/root/lib -L/root/path/to/lib1 -lmylib'
' -D_GLIBCXX_USE_CXX11_ABI=1 -F /root/Frameworks -std=gnu++17',
gcc.content)
settings.compiler.libcxx = "libstdc++"
gcc = GCCGenerator(conan_file)
self.assertEqual(
'-Dmydefine1 -I/root/include -I/root/path/to/include1'
' cxx_flag1 c_flag1 -m64 -g'
' -Wl,-rpath,"/root/lib" -Wl,-rpath,"/root/path/to/lib1"'
' -L/root/lib -L/root/path/to/lib1 -lmylib'
' -D_GLIBCXX_USE_CXX11_ABI=0 -F /root/Frameworks -std=gnu++17',
gcc.content)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "15"
settings.arch = "x86"
settings.build_type = "Release"
gcc = GCCGenerator(conan_file)
# GCC generator ignores the compiler setting, it is always gcc
self.assertEqual(
'-Dmydefine1 -I/root/include -I/root/path/to/include1'
' cxx_flag1 c_flag1 -m32 -O3 -s -DNDEBUG'
' -Wl,-rpath,"/root/lib" -Wl,-rpath,"/root/path/to/lib1"'
' -L/root/lib -L/root/path/to/lib1 -lmylib'
' -D_GLIBCXX_USE_CXX11_ABI=0 -F /root/Frameworks -std=gnu++17',
gcc.content)
def test_msvc_build_command(self):
settings = Settings.loads(get_default_settings_yml())
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "14"
# test build_type and arch override, for multi-config packages
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
cmd = tools.msvc_build_command(settings,
"project.sln",
build_type="Debug",
arch="x86",
output=self.output)
self.assertEqual(len(w), 3)
self.assertTrue(issubclass(w[0].category, DeprecationWarning))
self.assertIn(
'msbuild "project.sln" /p:Configuration="Debug" '
'/p:UseEnv=false /p:Platform="x86"', cmd)
self.assertIn('vcvarsall.bat', cmd)
# tests errors if args not defined
with six.assertRaisesRegex(self, ConanException,
"Cannot build_sln_command"):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
tools.msvc_build_command(settings,
"project.sln",
output=self.output)
self.assertEqual(len(w), 2)
self.assertTrue(issubclass(w[0].category, DeprecationWarning))
settings.arch = "x86"
with six.assertRaisesRegex(self, ConanException,
"Cannot build_sln_command"):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
tools.msvc_build_command(settings,
"project.sln",
output=self.output)
self.assertEqual(len(w), 2)
self.assertTrue(issubclass(w[0].category, DeprecationWarning))
# successful definition via settings
settings.build_type = "Debug"
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
cmd = tools.msvc_build_command(settings,
"project.sln",
output=self.output)
self.assertEqual(len(w), 3)
self.assertTrue(issubclass(w[0].category, DeprecationWarning))
self.assertIn(
'msbuild "project.sln" /p:Configuration="Debug" '
'/p:UseEnv=false /p:Platform="x86"', cmd)
self.assertIn('vcvarsall.bat', cmd)
def test_compatible(self, initial_version, toolset, expected_version):
info = ConanInfo()
settings = Settings.loads(default_settings_yml)
info.settings = settings
settings.compiler = "Visual Studio"
settings.compiler.toolset = toolset
settings.compiler.version = initial_version
info.full_settings = info.settings
info.vs_toolset_compatible()
self.assertEqual(info.settings.compiler.version, expected_version)
self.assertIsNone(info.settings.get_safe("compiler.toolset"))
def test_settings_model(self, use_settings_v1):
# First level setting 'cppstd' is no longer supported
settings = Settings.loads(get_default_settings_yml(force_v1=use_settings_v1))
if use_settings_v1:
settings.cppstd = "11"
with six.assertRaisesRegex(self, ConanV2Exception, "Setting 'cppstd' is deprecated"):
settings_preprocessor.preprocess(settings=settings)
else:
with six.assertRaisesRegex(self, ConanException, "'settings.cppstd' doesn't exist"):
settings.cppstd = "11"
settings_preprocessor.preprocess(settings=settings)
def test_incompatible(self, initial_version, toolset):
info = ConanInfo()
settings = Settings.loads(get_default_settings_yml())
info.settings = settings
settings.compiler = "Visual Studio"
settings.compiler.toolset = toolset
settings.compiler.version = initial_version
info.full_settings = info.settings
info.vs_toolset_compatible()
self.assertEqual(info.settings.compiler.version, initial_version)
self.assertEqual(info.settings.compiler.toolset, toolset)
def test_none_any(self):
yml = "os: [None, ANY]"
settings = Settings.loads(yml)
settings.validate()
settings.os = "None"
settings.validate()
self.assertTrue(settings.os == "None")
self.assertEqual("os=None", settings.values.dumps())
settings.os = "Windows"
self.assertTrue(settings.os == "Windows")
self.assertEqual("os=Windows", settings.values.dumps())
def test_cmake_system_version_android(self):
with tools.environment_append({"CONAN_CMAKE_SYSTEM_NAME": "SomeSystem",
"CONAN_CMAKE_GENERATOR": "SomeGenerator"}):
settings = Settings.loads(default_settings_yml)
settings.os = "WindowsStore"
settings.os.version = "8.1"
conan_file = ConanFileMock()
conan_file.settings = settings
cmake = CMake(conan_file)
self.assertEquals(cmake.definitions["CMAKE_SYSTEM_VERSION"], "8.1")
settings = Settings.loads(default_settings_yml)
settings.os = "Android"
settings.os.api_level = "32"
conan_file = ConanFileMock()
conan_file.settings = settings
cmake = CMake(conan_file)
self.assertEquals(cmake.definitions["CMAKE_SYSTEM_VERSION"], "32")
def test_any(self):
yml = "os: ANY"
settings = Settings.loads(yml)
with six.assertRaisesRegex(self, ConanException, "'settings.os' value not defined"):
settings.validate() # Raise exception if unset
settings.os = "None"
settings.validate()
self.assertTrue(settings.os == "None")
self.assertEqual("os=None", settings.values.dumps())
settings.os = "Windows"
self.assertTrue(settings.os == "Windows")
self.assertEqual("os=Windows", settings.values.dumps())
def compiler_args_test(self):
settings = Settings.loads(get_default_settings_yml())
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "15"
settings.arch = "x86"
settings.build_type = "Release"
conan_file = self._get_conanfile(settings)
gen = CompilerArgsGenerator(conan_file)
self.assertEqual(
'-Dmydefine1 -Ipath\\to\\include1 cxx_flag1 c_flag1 -O2 -Ob2 -DNDEBUG '
'-link -LIBPATH:path\\to\\lib1 mylib.lib', gen.content)
settings = Settings.loads(get_default_settings_yml())
settings.os = "Macos"
settings.compiler = "apple-clang"
settings.compiler.version = "9.0"
settings.arch = "x86"
settings.build_type = "Release"
conan_file = self._get_conanfile(settings)
gen = CompilerArgsGenerator(conan_file)
self.assertEqual(
'-Dmydefine1 -Ipath/to/include1 cxx_flag1 c_flag1 -m32 -O3 -DNDEBUG '
'-Wl,-rpath,"path/to/lib1" -Lpath/to/lib1 -lmylib', gen.content)
settings = Settings.loads(get_default_settings_yml())
settings.os = "Linux"
settings.os_build = "Macos"
settings.compiler = "apple-clang"
settings.compiler.version = "9.0"
settings.arch = "x86"
settings.build_type = "Release"
conan_file = self._get_conanfile(settings)
args = CompilerArgsGenerator(conan_file)
self.assertEqual(
'-Dmydefine1 -Ipath/to/include1 cxx_flag1 c_flag1 -m32 -O3 -DNDEBUG '
'-Wl,-rpath,"path/to/lib1" '
'-Lpath/to/lib1 -lmylib', args.content)
def vcvars_raises_when_not_found_test(self):
text = """
os: [Windows]
compiler:
Visual Studio:
version: ["5"]
"""
settings = Settings.loads(text)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "5"
with self.assertRaisesRegexp(ConanException, "VS non-existing installation: Visual Studio 5"):
tools.vcvars_command(settings)
def test_none_subsetting(self):
yml = """os:
None:
Windows:
subsystem: [None, cygwin]
"""
settings = Settings.loads(yml)
# Same sha as if settings were empty
self.assertEqual(settings.values.sha, Settings.loads("").values.sha)
settings.validate()
self.assertTrue(settings.os == None)
self.assertEqual("", settings.values.dumps())
settings.os = "None"
self.assertEqual(settings.values.sha, Settings.loads("").values.sha)
settings.validate()
self.assertTrue(settings.os == "None")
self.assertEqual("os=None", settings.values.dumps())
settings.os = "Windows"
self.assertTrue(settings.os.subsystem == None)
self.assertEqual("os=Windows", settings.values.dumps())
settings.os.subsystem = "cygwin"
self.assertEqual("os=Windows\nos.subsystem=cygwin", settings.values.dumps())
def vcvars_raises_when_not_found_test(self):
text = """
os: [Windows]
compiler:
Visual Studio:
version: ["5"]
"""
settings = Settings.loads(text)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "5"
with self.assertRaisesRegexp(ConanException, "VS non-existing installation: Visual Studio 5"):
tools.vcvars_command(settings)
def test_arch_override(self):
settings = Settings.loads(default_settings_yml)
settings.compiler = 'Visual Studio'
settings.compiler.version = '14'
settings.arch = 'mips64'
self.assert_vcvars_command(settings, "x86", arch='x86')
self.assert_vcvars_command(settings, "amd64", arch='x86_64')
self.assert_vcvars_command(settings, "amd64_arm", arch='armv7')
self.assert_vcvars_command(settings, "amd64_arm64", arch='armv8')
with self.assertRaises(ConanException):
tools.vcvars_command(settings, arch='mips')
def system_libs_test(self):
settings = Settings.loads(get_default_settings_yml())
settings.os = "Linux"
settings.compiler = "gcc"
settings.compiler.version = "8"
settings.arch = "x86_64"
settings.build_type = "Release"
conan_file = self._get_conanfile(settings, system_libs=True)
args = CompilerArgsGenerator(conan_file)
self.assertEqual('-Dmydefine1 -Ipath/to/include1 cxx_flag1 c_flag1 -m64 -O3 -s -DNDEBUG '
'-Wl,-rpath="path/to/lib1" -Lpath/to/lib1 -lmylib -lsystem_lib1',
args.content)
def test_81(self):
settings = Settings.loads(get_default_settings_yml())
settings.compiler = 'Visual Studio'
settings.compiler.version = '14'
settings.arch = 'x86'
settings.os = 'WindowsStore'
settings.os.version = '8.1'
command = tools.vcvars_command(settings, output=self.output)
self.assertIn('vcvarsall.bat', command)
self.assertIn('x86', command)
self.assertIn('store', command)
self.assertIn('8.1', command)
def test_none_subsetting(self):
yml = """os:
None:
Windows:
subsystem: [None, cygwin]
"""
settings = Settings.loads(yml)
# Same sha as if settings were empty
self.assertEqual(settings.values.sha, Settings.loads("").values.sha)
settings.validate()
self.assertTrue(settings.os == None)
self.assertEqual("", settings.values.dumps())
settings.os = "None"
self.assertEqual(settings.values.sha, Settings.loads("").values.sha)
settings.validate()
self.assertTrue(settings.os == "None")
self.assertEqual("os=None", settings.values.dumps())
settings.os = "Windows"
self.assertTrue(settings.os.subsystem == None)
self.assertEqual("os=Windows", settings.values.dumps())
settings.os.subsystem = "cygwin"
self.assertEqual("os=Windows\nos.subsystem=cygwin", settings.values.dumps())
def test_10_custom_winsdk(self):
settings = Settings.loads(get_default_settings_yml())
settings.compiler = 'Visual Studio'
settings.compiler.version = '14'
settings.arch = 'x86'
settings.os = 'WindowsStore'
settings.os.version = '10.0'
sdk_version = '10.0.18362.0'
command = tools.vcvars_command(settings, winsdk_version=sdk_version, output=self.output)
self.assertIn('vcvarsall.bat', command)
self.assertIn('x86', command)
self.assertIn('store', command)
self.assertIn(sdk_version, command)
def apple_frameworks_test(self):
settings = Settings.loads(get_default_settings_yml())
settings.os = "Macos"
settings.compiler = "apple-clang"
settings.compiler.version = "9.1"
settings.arch = "x86_64"
settings.build_type = "Release"
conan_file = self._get_conanfile(settings, frameworks=True)
args = CompilerArgsGenerator(conan_file)
self.assertEqual('-Dmydefine1 -Ipath/to/include1 cxx_flag1 c_flag1 -m64 -O3 -DNDEBUG '
'-Wl,-rpath,"path/to/lib1" -Lpath/to/lib1 -lmylib '
'-framework AVFoundation -framework VideoToolbox '
'-F path/to/Frameworks1 -F path/to/Frameworks2', args.content)
def test_different_arch(self):
settings = Settings.loads(get_default_settings_yml())
settings.os = "FreeBSD"
settings.arch = "x86"
self.assertTrue(
cross_building(settings, self_os="FreeBSD", self_arch="x86_64"))
with mock.patch("platform.system", mock.MagicMock(return_value='FreeBSD')), \
mock.patch("platform.machine", mock.MagicMock(return_value="x86_64")):
self.assertTrue(cross_building(settings))
settings.os_build = "FreeBSD"
settings.arch_build = "x86_64"
self.assertTrue(cross_building(settings))
def compiler_args_test(self):
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "15"
settings.arch = "x86"
settings.build_type = "Release"
conan_file = self._get_conanfile(settings)
gen = CompilerArgsGenerator(conan_file)
self.assertEquals('-Dmydefine1 -Ipath\\to\\include1 cxx_flag1 c_flag1 -O2 -Ob2 -DNDEBUG '
'-link -LIBPATH:path\\to\\lib1 mylib.lib', gen.content)
settings = Settings.loads(default_settings_yml)
settings.os = "Macos"
settings.compiler = "apple-clang"
settings.compiler.version = "9.0"
settings.arch = "x86"
settings.build_type = "Release"
conan_file = self._get_conanfile(settings)
gen = CompilerArgsGenerator(conan_file)
self.assertEquals('-Dmydefine1 -Ipath/to/include1 cxx_flag1 c_flag1 -m32 -O3 -DNDEBUG '
'-Wl,-rpath,"path/to/lib1" -Lpath/to/lib1 -lmylib', gen.content)
settings = Settings.loads(default_settings_yml)
settings.os = "Linux"
settings.os_build = "Macos"
settings.compiler = "apple-clang"
settings.compiler.version = "9.0"
settings.arch = "x86"
settings.build_type = "Release"
conan_file = self._get_conanfile(settings)
args = CompilerArgsGenerator(conan_file)
self.assertEquals('-Dmydefine1 -Ipath/to/include1 cxx_flag1 c_flag1 -m32 -O3 -DNDEBUG '
'-Wl,-rpath,"path/to/lib1" '
'-Lpath/to/lib1 -lmylib', args.content)
def test_winsdk_version_override(self):
settings = Settings.loads(default_settings_yml)
settings.compiler = 'Visual Studio'
settings.compiler.version = '15'
settings.arch = 'x86_64'
command = tools.vcvars_command(settings, winsdk_version='8.1')
self.assertIn('vcvarsall.bat', command)
self.assertIn('8.1', command)
settings.compiler.version = '14'
command = tools.vcvars_command(settings, winsdk_version='8.1')
self.assertIn('vcvarsall.bat', command)
self.assertIn('8.1', command)
def test_cmake_definitions(self, conan_arch, conan_os, expected_arch,
expected_os):
settings = Settings.loads(get_default_settings_yml())
settings.os = conan_os
settings.compiler = "apple-clang"
settings.compiler.version = "11.0"
settings.arch = conan_arch
conanfile = ConanFileMock()
conanfile.settings = settings
cmake = CMake(conanfile)
self.assertEqual(cmake.definitions["CMAKE_OSX_ARCHITECTURES"],
expected_arch)
self.assertIn(expected_os, cmake.definitions["CMAKE_OSX_SYSROOT"])
def vcvars_amd64_32_cross_building_support_test(self):
# amd64_x86 crossbuilder
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "15"
settings.arch = "x86"
settings.arch_build = "x86_64"
cmd = tools.vcvars_command(settings, output=self.output)
self.assertIn('vcvarsall.bat" amd64_x86', cmd)
# It follows arch_build first
settings.arch_build = "x86"
cmd = tools.vcvars_command(settings, output=self.output)
self.assertIn('vcvarsall.bat" x86', cmd)
def test_vcvars_ver_override(self):
settings = Settings.loads(default_settings_yml)
settings.compiler = 'Visual Studio'
settings.compiler.version = '15'
settings.arch = 'x86_64'
command = tools.vcvars_command(settings, vcvars_ver='14.14', output=self.output)
self.assertIn('vcvarsall.bat', command)
self.assertIn('-vcvars_ver=14.14', command)
settings.compiler.version = '14'
command = tools.vcvars_command(settings, vcvars_ver='14.14', output=self.output)
self.assertIn('vcvarsall.bat', command)
self.assertIn('-vcvars_ver=14.14', command)
def test_81(self):
if platform.system() != "Windows":
return
settings = Settings.loads(default_settings_yml)
settings.compiler = 'Visual Studio'
settings.compiler.version = '14'
settings.arch = 'x86'
settings.os = 'WindowsStore'
settings.os.version = '8.1'
command = tools.vcvars_command(settings, output=self.output)
self.assertIn('vcvarsall.bat', command)
self.assertIn('x86', command)
self.assertIn('store', command)
self.assertIn('8.1', command)
def set_toolset_test(self):
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "15"
settings.arch = "x86"
conan_file = ConanFileMock()
conan_file.settings = settings
cmake = CMake(conan_file, toolset="v141")
self.assertIn('-T "v141"', cmake.command_line)
with tools.environment_append({"CONAN_CMAKE_TOOLSET": "v141"}):
cmake = CMake(conan_file)
self.assertIn('-T "v141"', cmake.command_line)
def test_81(self):
if platform.system() != "Windows":
return
settings = Settings.loads(default_settings_yml)
settings.compiler = 'Visual Studio'
settings.compiler.version = '14'
settings.arch = 'x86'
settings.os = 'WindowsStore'
settings.os.version = '8.1'
command = tools.vcvars_command(settings)
self.assertIn('vcvarsall.bat', command)
self.assertIn('x86', command)
self.assertIn('store', command)
self.assertIn('8.1', command)
def b2_test(self):
settings = Settings.loads(get_default_settings_yml())
settings.os = "Linux"
settings.compiler = "gcc"
settings.compiler.version = "6.3"
settings.arch = "x86"
settings.build_type = "Release"
settings.cppstd = "gnu17"
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
conanfile.settings = settings
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.defines = ["MYDEFINE1"]
cpp_info.cflags.append("-Flag1=23")
cpp_info.version = "1.3"
cpp_info.description = "My cool description"
cpp_info.libs = ["MyLib1"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.libs = ["MyLib2"]
cpp_info.defines = ["MYDEFINE2"]
cpp_info.version = "2.3"
cpp_info.exelinkflags = ["-exelinkflag"]
cpp_info.sharedlinkflags = ["-sharedlinkflag"]
cpp_info.cxxflags = ["-cxxflag"]
cpp_info.public_deps = ["MyPkg"]
cpp_info.libdirs.extend(["Path\\with\\slashes", "regular/path/to/dir"])
cpp_info.includedirs.extend(
["other\\Path\\with\\slashes", "other/regular/path/to/dir"])
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = B2Generator(conanfile)
content = {
'conanbuildinfo.jam': _main_buildinfo_full,
'conanbuildinfo-316f2f0b155dc874a672d40d98d93f95.jam':
_variation_full,
}
for ck, cv in generator.content.items():
self.assertEqual(cv, content[ck])
def test_sysroot(self):
settings = Settings.loads(default_settings_yml)
conan_file = ConanFileMock()
conan_file.settings = settings
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "12"
settings.arch = "x86"
settings.os = "Windows"
cmake = CMake(conan_file)
self.assertNotIn("-DCMAKE_SYSROOT=", cmake.flags) if platform.system() == "Windows" else ""
# Now activate cross build and check sysroot
with(tools.environment_append({"CONAN_CMAKE_SYSTEM_NAME": "Android"})):
cmake = CMake(conan_file)
self.assertEquals(cmake.definitions["CMAKE_SYSROOT"], "/path/to/sysroot")
def loads_default_test(self):
settings = Settings.loads("""os: [Windows, Linux, Macos, Android, FreeBSD]
arch: [x86, x86_64, arm]
compiler:
gcc:
version: ["4.8", "4.9", "5.0"]
Visual Studio:
runtime: [None, MD, MT, MTd, MDd]
version: ["10", "11", "12"]
clang:
version: ["3.5", "3.6", "3.7"]
build_type: [None, Debug, Release]""")
settings.compiler = "clang"
settings.compiler.version = "3.5"
self.assertEqual(settings.compiler, "clang")
self.assertEqual(settings.compiler.version, "3.5")
def setUp(self):
self.output = TestBufferConanOutput()
self.loader = ConanFileLoader(None, Settings.loads(""), Profile())
self.retriever = Retriever(self.loader, self.output)
self.remote_search = MockSearchRemote()
self.resolver = RequireResolver(self.output, self.retriever, self.remote_search)
self.builder = DepsGraphBuilder(self.retriever, self.output, self.loader, self.resolver)
for v in ["0.1", "0.2", "0.3", "1.1", "1.1.2", "1.2.1", "2.1", "2.2.1"]:
say_content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "%s"
""" % v
say_ref = ConanFileReference.loads("Say/%s@memsharded/testing" % v)
self.retriever.conan(say_ref, say_content)
def deleted_os_test(self):
partial_settings = """
os: [Linux]
arch: [x86_64]
compiler:
gcc:
version: ["4.9"]
build_type: [ Release]
"""
settings = Settings.loads(partial_settings)
settings.os = "Linux"
settings.compiler = "gcc"
settings.compiler.version = "4.9"
settings.arch = "x86_64"
cmake = CMake(settings)
self.assertEqual('-G "Unix Makefiles" -DCONAN_COMPILER="gcc" '
'-DCONAN_COMPILER_VERSION="4.9" -Wno-dev', cmake.command_line)
def settings_are_generated_tests(self):
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "12"
settings.compiler.runtime = "MD"
settings.arch = "x86"
settings.build_type = "Debug"
conanfile = ConanFile(None, None, Settings({}), None)
conanfile.settings = settings
generator = CMakeGenerator(conanfile)
content = generator.content
cmake_lines = content.splitlines()
self.assertIn('set(CONAN_SETTINGS_BUILD_TYPE "Debug")', cmake_lines)
self.assertIn('set(CONAN_SETTINGS_ARCH "x86")', cmake_lines)
self.assertIn('set(CONAN_SETTINGS_COMPILER "Visual Studio")', cmake_lines)
self.assertIn('set(CONAN_SETTINGS_COMPILER_VERSION "12")', cmake_lines)
self.assertIn('set(CONAN_SETTINGS_COMPILER_RUNTIME "MD")', cmake_lines)
self.assertIn('set(CONAN_SETTINGS_OS "Windows")', cmake_lines)
def test_10(self):
if platform.system() != "Windows":
return
sdk_version = tools.find_windows_10_sdk()
if not sdk_version:
return
settings = Settings.loads(default_settings_yml)
settings.compiler = 'Visual Studio'
settings.compiler.version = '14'
settings.arch = 'x86'
settings.os = 'WindowsStore'
settings.os.version = '10.0'
command = tools.vcvars_command(settings)
self.assertIn('vcvarsall.bat', command)
self.assertIn('x86', command)
self.assertIn('store', command)
self.assertIn(sdk_version, command)
def gcc_test(self):
settings = Settings.loads(default_settings_yml)
settings.os = "Linux"
settings.compiler = "gcc"
settings.compiler.version = "6.3"
settings.arch = "x86"
settings.build_type = "Release"
settings.cppstd = "gnu17"
conan_file = self._get_conanfile(settings)
gcc = GCCGenerator(conan_file)
self.assertEquals('-Dmydefine1 -Ipath/to/include1 cxx_flag1 c_flag1 -m32 -O3 -s -DNDEBUG '
'-Wl,-rpath="path/to/lib1" '
'-Lpath/to/lib1 -lmylib -std=gnu++1z', gcc.content)
settings.arch = "x86_64"
settings.build_type = "Debug"
settings.compiler.libcxx = "libstdc++11"
gcc = GCCGenerator(conan_file)
self.assertEquals('-Dmydefine1 -Ipath/to/include1 cxx_flag1 c_flag1 -m64 -g '
'-Wl,-rpath="path/to/lib1" -Lpath/to/lib1 -lmylib '
'-D_GLIBCXX_USE_CXX11_ABI=1 -std=gnu++1z',
gcc.content)
settings.compiler.libcxx = "libstdc++"
gcc = GCCGenerator(conan_file)
self.assertEquals('-Dmydefine1 -Ipath/to/include1 cxx_flag1 c_flag1 -m64 -g '
'-Wl,-rpath="path/to/lib1" -Lpath/to/lib1 -lmylib '
'-D_GLIBCXX_USE_CXX11_ABI=0 -std=gnu++1z',
gcc.content)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "15"
settings.arch = "x86"
settings.build_type = "Release"
gcc = GCCGenerator(conan_file)
# GCC generator ignores the compiler setting, it is always gcc
self.assertEquals('-Dmydefine1 -Ipath/to/include1 cxx_flag1 c_flag1 -m32 -O3 -s '
'-DNDEBUG -Wl,-rpath="path/to/lib1" -Lpath/to/lib1 -lmylib',
gcc.content)
def multi_os_test(self):
settings = Settings.loads("""os:
Windows:
Linux:
distro: [RH6, RH7]
Macos:
codename: [Mavericks, Yosemite]
""")
settings.os = "Windows"
self.assertEqual(settings.os, "Windows")
settings.os = "Linux"
settings.os.distro = "RH6"
self.assertTrue(settings.os.distro == "RH6")
with self.assertRaises(ConanException):
settings.os.distro = "Other"
with self.assertRaises(ConanException):
settings.os.codename = "Yosemite"
settings.os = "Macos"
settings.os.codename = "Yosemite"
self.assertTrue(settings.os.codename == "Yosemite")
def loads_test(self):
settings = Settings.loads("""
compiler:
Visual Studio:
runtime: [MD, MT]
version:
'10':
arch: ["32"]
'11':
&id1
arch: ["32", "64"]
'12':
*id1
gcc:
arch:
x64:
speed: [C, D]
x86:
speed: [A, B]
version: ['4.8', '4.9']
os: [Windows, Linux]
""")
settings.values_list = [('compiler', 'Visual Studio'),
('compiler.version', '10'),
('compiler.version.arch', '32')]
self.assertEqual(settings.values_list,
[('compiler', 'Visual Studio'),
('compiler.version', '10'),
('compiler.version.arch', '32')])
settings.compiler.version = "10"
settings.compiler.version.arch = "32"
settings.compiler.version = "11"
settings.compiler.version.arch = "64"
settings.compiler.version = "12"
settings.compiler.version.arch = "64"
self.assertEqual(settings.values_list,
[('compiler', 'Visual Studio'),
('compiler.version', '12'),
('compiler.version.arch', '64')])
def vcvars_constrained_test(self):
if platform.system() != "Windows":
return
text = """os: [Windows]
compiler:
Visual Studio:
version: ["14"]
"""
settings = Settings.loads(text)
settings.os = "Windows"
settings.compiler = "Visual Studio"
with self.assertRaisesRegexp(ConanException,
"compiler.version setting required for vcvars not defined"):
tools.vcvars_command(settings)
settings.compiler.version = "14"
cmd = tools.vcvars_command(settings)
self.assertIn("vcvarsall.bat", cmd)
with tools.environment_append({"VisualStudioVersion": "12"}):
with self.assertRaisesRegexp(ConanException,
"Error, Visual environment already set to 12"):
tools.vcvars_command(settings)
def vcvars_echo_test(self):
if platform.system() != "Windows":
return
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "14"
cmd = tools.vcvars_command(settings)
output = TestBufferConanOutput()
runner = TestRunner(output)
runner(cmd + " && set vs140comntools")
self.assertIn("vcvarsall.bat", str(output))
self.assertIn("VS140COMNTOOLS=", str(output))
with tools.environment_append({"VisualStudioVersion": "14"}):
output = TestBufferConanOutput()
runner = TestRunner(output)
cmd = tools.vcvars_command(settings)
runner(cmd + " && set vs140comntools")
self.assertNotIn("vcvarsall.bat", str(output))
self.assertIn("Conan:vcvars already set", str(output))
self.assertIn("VS140COMNTOOLS=", str(output))
def deleted_os_test(self):
partial_settings = """
os: [Linux]
arch: [x86_64]
compiler:
gcc:
version: ["4.9"]
build_type: [ Release]
"""
settings = Settings.loads(partial_settings)
settings.os = "Linux"
settings.compiler = "gcc"
settings.compiler.version = "4.9"
settings.arch = "x86_64"
conan_file = ConanFileMock()
conan_file.settings = settings
cmake = CMake(conan_file)
cross = "-DCMAKE_SYSTEM_NAME=\"Linux\" -DCMAKE_SYSROOT=\"/path/to/sysroot\" " if platform.system() != "Linux" else ""
self.assertEqual('-G "Unix Makefiles" %s-DCONAN_EXPORTED="1" -DCONAN_COMPILER="gcc" '
'-DCONAN_COMPILER_VERSION="4.9" -DCONAN_CXX_FLAGS="-m64" '
'-DCONAN_SHARED_LINKER_FLAGS="-m64" -DCONAN_C_FLAGS="-m64" -Wno-dev' % cross,
cmake.command_line)
def msvc_build_command_test(self):
if platform.system() != "Windows":
return
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "14"
# test build_type and arch override, for multi-config packages
cmd = tools.msvc_build_command(settings, "project.sln", build_type="Debug", arch="x86")
self.assertIn('msbuild project.sln /p:Configuration=Debug /p:Platform="x86"', cmd)
self.assertIn('vcvarsall.bat', cmd)
# tests errors if args not defined
with self.assertRaisesRegexp(ConanException, "Cannot build_sln_command"):
tools.msvc_build_command(settings, "project.sln")
settings.arch = "x86"
with self.assertRaisesRegexp(ConanException, "Cannot build_sln_command"):
tools.msvc_build_command(settings, "project.sln")
# succesful definition via settings
settings.build_type = "Debug"
cmd = tools.msvc_build_command(settings, "project.sln")
self.assertIn('msbuild project.sln /p:Configuration=Debug /p:Platform="x86"', cmd)
self.assertIn('vcvarsall.bat', cmd)
def valid_xml_test(self, use_toolset):
tempdir = temp_folder()
with chdir(tempdir):
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "11"
settings.compiler.runtime = "MD"
if use_toolset:
settings.compiler.toolset = "v110"
conanfile = ConanFile(None, None, Settings({}), None)
ref = ConanFileReference.loads("MyPkg/0.1@user/testing")
cpp_info = CppInfo("dummy_root_folder1")
conanfile.deps_cpp_info.update(cpp_info, ref.name)
ref = ConanFileReference.loads("My.Fancy-Pkg_2/0.1@user/testing")
cpp_info = CppInfo("dummy_root_folder2")
conanfile.deps_cpp_info.update(cpp_info, ref.name)
settings.arch = "x86"
settings.build_type = "Debug"
conanfile.settings = settings
generator = VisualStudioMultiGenerator(conanfile)
generator.output_path = ""
content = generator.content
self.assertEqual(2, len(content))
self.assertIn('conanbuildinfo_multi.props', content.keys())
self.assertIn('conanbuildinfo_debug_win32_v110.props', content.keys())
content_multi = content['conanbuildinfo_multi.props']
self.assertIn("<Import Condition=\"'$(Configuration)' == 'Debug' "
"And '$(Platform)' == 'Win32' "
"And '$(PlatformToolset)' == 'v110'\" "
"Project=\"conanbuildinfo_debug_win32_v110.props\"/>", content_multi)
with open('conanbuildinfo_multi.props', 'w') as f:
f.write(content_multi)
settings.arch = "x86_64"
settings.build_type = "Release"
settings.compiler.version = "15"
settings.compiler.toolset = "v141"
conanfile.settings = settings
generator = VisualStudioMultiGenerator(conanfile)
generator.output_path = ""
content = generator.content
self.assertEqual(2, len(content))
self.assertIn('conanbuildinfo_multi.props', content.keys())
self.assertIn('conanbuildinfo_release_x64_v141.props', content.keys())
content_multi = content['conanbuildinfo_multi.props']
self.assertIn("<Import Condition=\"'$(Configuration)' == 'Debug' "
"And '$(Platform)' == 'Win32' "
"And '$(PlatformToolset)' == 'v110'\" "
"Project=\"conanbuildinfo_debug_win32_v110.props\"/>", content_multi)
self.assertIn("<Import Condition=\"'$(Configuration)' == 'Release' "
"And '$(Platform)' == 'x64' "
"And '$(PlatformToolset)' == 'v141'\" "
"Project=\"conanbuildinfo_release_x64_v141.props\"/>", content_multi)
os.unlink('conanbuildinfo_multi.props')
