def test_invalid_target_triple():
conanfile = ConanFileMock()
conanfile.settings = MockSettings({"os": "Linux", "arch": "UNKNOWN_ARCH"})
conanfile.settings_build = MockSettings({"os": "Solaris", "arch": "x86"})
with pytest.raises(ConanException) as excinfo:
AutotoolsToolchain(conanfile)
assert "Unknown 'UNKNOWN_ARCH' machine, Conan doesn't know how " \
"to translate it to the GNU triplet," in str(excinfo)
def test_sysroot_flag(self):
sysroot = sysroot_flag(sysroot=None, settings=MockSettings({}))
self.assertEqual(sysroot, "")
sysroot = sysroot_flag(sysroot='sys/root',
settings=MockSettings({"compiler": "Visual Studio"}))
self.assertEqual(sysroot, "")
sysroot = sysroot_flag(sysroot='sys/root', settings=MockSettings({}))
self.assertEqual(sysroot, "--sysroot=sys/root")
def test_adjust_path(self):
settings = MockSettings({"compiler": 'gcc'})
self.assertEqual('home/www', adjust_path('home\\www',
MockSettings({})))
self.assertEqual('home/www', adjust_path('home\\www', settings))
self.assertEqual('"home/www root"',
adjust_path('home\\www root', MockSettings({})))
self.assertEqual('"home/www root"',
adjust_path('home\\www root', settings))
def test_cross_build_command(self):
runner = RunnerMock()
conanfile = MockConanfile(MockSettings({}), None, runner)
ab = AutoToolsBuildEnvironment(conanfile)
self.assertFalse(ab.build)
self.assertFalse(ab.host)
self.assertFalse(ab.target)
ab.configure()
self.assertEqual(runner.command_called, "./configure ")
ab.configure(host="x86_64-apple-darwin")
self.assertEqual(runner.command_called, "./configure --host=x86_64-apple-darwin")
ab.configure(build="arm-apple-darwin")
self.assertEqual(runner.command_called, "./configure --build=arm-apple-darwin")
ab.configure(target="i686-apple-darwin")
self.assertEqual(runner.command_called, "./configure --target=i686-apple-darwin")
conanfile = MockConanfile(MockSettings({"build_type": "Debug",
"arch": "x86_64",
"os": "Windows",
"compiler": "gcc",
"compiler.libcxx": "libstdc++"}),
None, runner)
ab = AutoToolsBuildEnvironment(conanfile)
ab.configure()
if platform.system() == "Windows":
# Not crossbuilding
self.assertFalse(ab.host)
self.assertFalse(ab.build)
self.assertIn("./configure", runner.command_called)
self.assertNotIn("--build=x86_64-w64-mingw32 --host=x86_64-w64-mingw32",
runner.command_called)
elif platform.system() == "Linux":
self.assertIn("x86_64-w64-mingw32", ab.host)
self.assertIn("x86_64-linux-gnu", ab.build)
self.assertIn("./configure --build=x86_64-linux-gnu --host=x86_64-w64-mingw32",
runner.command_called)
else:
self.assertIn("x86_64-w64-mingw32", ab.host)
self.assertIn("x86_64-apple-darwin", ab.build)
self.assertIn("./configure --build=x86_64-apple-darwin --host=x86_64-w64-mingw32",
runner.command_called)
ab.configure(build="fake_build_triplet", host="fake_host_triplet")
self.assertIn("./configure --build=fake_build_triplet --host=fake_host_triplet",
runner.command_called)
ab.build = "superfake_build_triplet"
ab.host = "superfake_host_triplet"
ab.configure()
self.assertIn("./configure --build=superfake_build_triplet --host=superfake_host_triplet",
runner.command_called)
def test_cppstd():
# Using "cppstd" is discarded
conanfile = ConanFileMock()
conanfile.settings = MockSettings({
"build_type": "Release",
"arch": "x86",
"compiler": "gcc",
"compiler.libcxx": "libstdc++11",
"compiler.version": "7.1",
"cppstd": "17"
})
be = AutotoolsToolchain(conanfile)
env = be.vars()
assert "-std=c++17" not in env["CXXFLAGS"]
# Using "compiler.cppstd" works
conanfile.settings = MockSettings({
"build_type": "Release",
"arch": "x86",
"compiler": "gcc",
"compiler.libcxx": "libstdc++11",
"compiler.version": "7.1",
"compiler.cppstd": "17"
})
be = AutotoolsToolchain(conanfile)
env = be.vars()
assert "-std=c++17" in env["CXXFLAGS"]
# With visual
conanfile.settings = MockSettings({
"build_type": "Release",
"arch": "x86",
"compiler": "Visual Studio",
"compiler.version": "14",
"compiler.cppstd": "17"
})
be = AutotoolsToolchain(conanfile)
env = be.vars()
assert "/std:c++latest" in env["CXXFLAGS"]
# With MSVC
conanfile.settings = MockSettings({
"build_type": "Release",
"arch": "x86",
"compiler": "msvc",
"compiler.version": "193",
"compiler.cppstd": "17"
})
be = AutotoolsToolchain(conanfile)
env = be.vars()
assert "/std:c++17" in env["CXXFLAGS"]
def test_ndebug():
conanfile = ConanFileMock()
for bt in ['Release', 'RelWithDebInfo', 'MinSizeRel']:
conanfile.settings = MockSettings({"build_type": bt})
be = AutotoolsToolchain(conanfile)
assert be.ndebug == "NDEBUG"
env = be.vars()
assert "-DNDEBUG" in env["CPPFLAGS"]
for bt in ['Debug', 'DebWithDebInfo']:
conanfile.settings = MockSettings({"build_type": bt})
be = AutotoolsToolchain(conanfile)
assert be.ndebug is None
env = be.vars()
assert "-DNDEBUG" not in env["CPPFLAGS"]
def test_pic_flags(self):
flag = pic_flag(MockSettings({}))
self.assertEqual(flag, '')
flags = pic_flag(MockSettings({"compiler": 'gcc'}))
self.assertEqual(flags, '-fPIC')
flags = pic_flag(MockSettings({"compiler": 'Visual Studio'}))
self.assertEqual(flags, "")
flags = pic_flag(MockSettings({"compiler": 'intel', "compiler.base": "gcc"}))
self.assertEqual(flags, '-fPIC')
flags = pic_flag(MockSettings({"compiler": 'intel', "compiler.base": "Visual Studio"}))
self.assertEqual(flags, '')
def test_convert_target_platform(self):
conanfile = MockConanfileWithFolders(MockSettings({'compiler': 'gcc'}))
qbs_toolchain = qbs.QbsToolchain(conanfile)
self.assertEqual(qbs_toolchain._target_platform, None)
for os, target_platform in qbs._target_platform.items():
conanfile = MockConanfileWithFolders(
MockSettings({
'os': os,
'compiler': 'gcc'
}))
qbs_toolchain = qbs.QbsToolchain(conanfile)
self.assertEqual(qbs_toolchain._target_platform, target_platform)
def test_read_qbs_toolchain_from_qbs_config_output(self):
expected_config = {
'cpp.cCompilerName': '"gcc"',
'cpp.compilerName': '"g++"',
'cpp.cxxCompilerName': '"g++"',
'cpp.driverFlags':
'["-march=armv7e-m", "-mtune=cortex-m4", "--specs=nosys.specs"]',
'cpp.platformCommonCompilerFlags': 'undefined',
'cpp.platformLinkerFlags': 'undefined',
'cpp.toolchainInstallPath': '"/usr/bin"',
'cpp.toolchainPrefix': '"arm-none-eabi-"',
'qbs.someBoolProp': 'true',
'qbs.someIntProp': '13',
'qbs.toolchain': '["gcc"]'
}
conanfile = MockConanfileWithFolders(
MockSettings({}),
runner=RunnerMock(expectations=[
RunnerMock.Expectation(
output=self._generate_qbs_config_output())
]))
config = qbs._read_qbs_toolchain_from_config(conanfile)
self.assertEqual(len(conanfile.runner.command_called), 1)
self.assertEqual(
conanfile.runner.command_called[0],
'qbs-config --settings-dir "%s" --list' %
(qbs._settings_dir(conanfile)))
self.assertEqual(config, expected_config)
def test_negative(self):
self.assertIsNone(
tools.msvs_toolset(
MockSettings({
"compiler": "Visual Studio",
"compiler.version": "666"
})))
def test_custom(self, compiler_version, expected_toolset):
settings = MockSettings({
"compiler": "Visual Studio",
"compiler.version": compiler_version,
"compiler.toolset": expected_toolset
})
self.assertEqual(expected_toolset, tools.msvs_toolset(settings))
def test_solaris(self):
with mock.patch("platform.system", mock.MagicMock(return_value='SunOS')), \
mock.patch("platform.machine", mock.MagicMock(return_value="x86_64")):
conanfile = MockConanfile(MockSettings({}))
build_os, build_arch, _, _ = get_cross_building_settings(conanfile)
self.assertEqual("SunOS", build_os)
self.assertEqual("x86_64", build_arch)
def test_arch_flag(self, compiler, arch, the_os, flag):
settings = MockSettings({
"compiler": compiler,
"arch": arch,
"os": the_os
})
self.assertEqual(architecture_flag(settings), flag)
def test_read_qbs_toolchain_from_qbs_config_output_msvc(self):
expected_config = {
'cpp.compilerVersion': '"19.28.29333"',
'cpp.toolchainInstallPath':
'"C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.28.29333/bin/Hostx64/x64"',
'qbs.architecture': '"x86_64"',
'qbs.targetPlatform': '"windows"',
'qbs.toolchainType': '"msvc"',
'cpp.driverFlags':
'["-march=armv7e-m", "-mtune=cortex-m4", "--specs=nosys.specs"]',
'qbs.someBoolProp': 'true',
'qbs.someIntProp': '13',
}
conanfile = MockConanfileWithFolders(
MockSettings({}),
runner=RunnerMock(expectations=[
RunnerMock.Expectation(
output=self._generate_qbs_config_output_msvc())
]))
config = qbs._read_qbs_toolchain_from_config(conanfile)
self.assertEqual(len(conanfile.runner.command_called), 1)
self.assertEqual(
conanfile.runner.command_called[0],
'qbs-config --settings-dir "%s" --list' %
(qbs._settings_dir(conanfile)))
self.assertEqual(config, expected_config)
def test_construct_build_helper_without_project_file(self):
conanfile = MockConanfile(
MockSettings({'os': 'Linux', 'compiler': 'gcc'}))
conanfile.source_folder = '.'
build_helper = qbs.Qbs(conanfile)
self.assertEqual(build_helper.jobs, tools.cpu_count())
self.assertEqual(build_helper._project_file, conanfile.source_folder)
def test_rpath_optin(self):
settings = MockSettings({
"os_build": "Linux",
"build_type": "Release",
"arch": "x86_64",
"compiler": "gcc",
"compiler.libcxx": "libstdc++11"
})
conanfile = MockConanfile(settings)
conanfile.settings = settings
self._set_deps_info(conanfile)
expected = {
'CFLAGS':
'a_c_flag -m64 -O3 -s --sysroot=/path/to/folder',
'CPPFLAGS':
'-Ipath/includes -Iother/include/path -Donedefinition -Dtwodefinition -DNDEBUG '
'-D_GLIBCXX_USE_CXX11_ABI=1',
'CXXFLAGS':
'a_c_flag -m64 -O3 -s --sysroot=/path/to/folder a_cxx_flag',
'LDFLAGS':
'shared_link_flag exe_link_flag -framework oneframework -framework twoframework '
'-F one/framework/path -m64 --sysroot=/path/to/folder '
'-Wl,-rpath,"one/lib/path" -Lone/lib/path',
'LIBS':
'-lonelib -ltwolib -lonesystemlib -ltwosystemlib'
}
be = AutoToolsBuildEnvironment(conanfile, include_rpath_flags=True)
self.assertEqual(be.vars, expected)
def test_modify_values(self):
settings = MockSettings({
"build_type": "Debug",
"arch": "x86_64",
"compiler": "gcc",
"compiler.libcxx": "libstdc++"
})
conanfile = MockConanfile(settings)
conanfile.settings = settings
self._set_deps_info(conanfile)
be = AutoToolsBuildEnvironment(conanfile)
# Alter some things
be.defines.append("OtherDefinition=23")
be.link_flags = ["-inventedflag"]
be.cxx_flags.append("-onlycxx")
be.fpic = True
be.flags.append("cucucu")
expected = {
'CFLAGS':
'a_c_flag -m64 -g --sysroot=/path/to/folder cucucu -fPIC',
'CPPFLAGS':
'-Ipath/includes -Iother/include/path -Donedefinition -Dtwodefinition'
' -D_GLIBCXX_USE_CXX11_ABI=0 -DOtherDefinition=23',
'CXXFLAGS':
'a_c_flag -m64 -g --sysroot=/path/to/folder cucucu -fPIC a_cxx_flag -onlycxx',
'LDFLAGS':
'-inventedflag -Lone/lib/path',
'LIBS':
'-lonelib -ltwolib -lonesystemlib -ltwosystemlib'
}
self.assertEqual(be.vars, expected)
def test_environment_append(self):
settings = MockSettings({"build_type": "Debug",
"arch": "x86_64",
"compiler": "gcc",
"compiler.libcxx": "libstdc++"})
conanfile = MockConanfile(settings)
conanfile.settings = settings
self._set_deps_info(conanfile)
env_vars = {"CFLAGS": "-additionalcflag",
"CXXFLAGS": "-additionalcxxflag",
"LDFLAGS": "-additionalldflag",
"LIBS": "-additionallibs",
"CPPFLAGS": "-additionalcppflag"}
with(tools.environment_append(env_vars)):
be = AutoToolsBuildEnvironment(conanfile)
expected = {'CPPFLAGS': '-Ipath/includes -Iother/include/path -Donedefinition -'
'Dtwodefinition -D_GLIBCXX_USE_CXX11_ABI=0 -additionalcppflag',
'CXXFLAGS': 'a_c_flag -m64 -g --sysroot=/path/to/folder a_cxx_flag -additionalcxxflag',
'LIBS': '-lonelib -ltwolib -lonesystemlib -ltwosystemlib -additionallibs',
'LDFLAGS': 'shared_link_flag exe_link_flag -framework oneframework '
'-framework twoframework -F one/framework/path -m64 '
'--sysroot=/path/to/folder -Lone/lib/path -additionalldflag',
'CFLAGS': 'a_c_flag -m64 -g --sysroot=/path/to/folder -additionalcflag'}
self.assertEqual(be.vars, expected)
def _make_cppstd_flag(compiler, compiler_version, cppstd=None, compiler_base=None):
settings = MockSettings({"compiler": compiler,
"compiler.version": compiler_version,
"compiler.cppstd": cppstd})
if compiler_base:
settings.values["compiler.base"] = compiler_base
return cppstd_flag(settings)
def test_arch_flag_mcst_lcc(self, arch, flag):
settings = MockSettings({
"compiler": "mcst-lcc",
"compiler.base": "gcc",
"arch": arch
})
self.assertEqual(architecture_flag(settings), flag)
def test_arch_flag_intel(self, base, arch, flag):
settings = MockSettings({
"compiler": "intel",
"compiler.base": base,
"arch": arch
})
self.assertEqual(architecture_flag(settings), flag)
def test_skip_toolset(self):
settings = MockSettings({"build_type": "Debug",
"compiler": "Visual Studio",
"compiler.version": "15",
"arch": "x86_64"})
class Runner(object):
def __init__(self):
self.commands = []
def __call__(self, *args, **kwargs):
self.commands.append(args[0])
with chdir(tools.mkdir_tmp()):
runner = Runner()
conanfile = MockConanfile(settings, runner=runner)
msbuild = MSBuild(conanfile)
msbuild.build("myproject", toolset=False)
self.assertEqual(len(runner.commands), 1)
self.assertNotIn("PlatformToolset", runner.commands[0])
runner = Runner()
conanfile = MockConanfile(settings, runner=runner)
msbuild = MSBuild(conanfile)
msbuild.build("myproject", toolset="mytoolset")
self.assertEqual(len(runner.commands), 1)
self.assertIn('/p:PlatformToolset="mytoolset"', runner.commands[0])
def test_convert_runtime_library(self):
conanfile = MockConanfileWithFolders(
MockSettings({'compiler': 'Visual Studio'}))
qbs_toolchain = qbs.QbsProfile(conanfile)
self.assertEqual(qbs_toolchain._runtime_library, None)
for runtime, runtime_library in qbs._runtime_library.items():
conanfile = MockConanfileWithFolders(
MockSettings({
'compiler': 'Visual Studio',
'compiler.runtime': runtime
}))
qbs_toolchain = qbs.QbsProfile(conanfile)
self.assertEqual(qbs_toolchain._runtime_library, runtime_library)
def toolset_test(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
new_out = StringIO()
command = build_sln_command(MockSettings({
"compiler": "Visual Studio",
"compiler.version": "17",
"build_type": "Debug",
"compiler.runtime": "MDd",
"cppstd": "17"
}),
sln_path='dummy.sln',
targets=None,
upgrade_project=False,
build_type='Debug',
arch='armv7',
parallel=False,
toolset="v110",
output=ConanOutput(new_out))
self.assertEqual(len(w), 1)
self.assertTrue(issubclass(w[0].category, DeprecationWarning))
self.assertTrue(
command.startswith('msbuild "dummy.sln" /p:Configuration="Debug" '
'/p:UseEnv=false '
'/p:Platform="ARM" '
'/p:PlatformToolset="v110" '
'/verbosity:minimal '
'/p:ForceImportBeforeCppTargets='), command)
def test_autotools_configure_vars(self):
from mock import patch
runner = RunnerMock()
settings = MockSettings({"build_type": "Debug",
"arch": "x86_64",
"compiler": "gcc",
"compiler.libcxx": "libstdc++"})
conanfile = MockConanfile(settings, None, runner)
conanfile.settings = settings
self._set_deps_info(conanfile)
def custom_configure(obj, configure_dir=None, args=None, build=None, host=None, target=None,
pkg_config_paths=None, vars=None): # @UnusedVariable
self.assertNotEqual(obj.vars, vars)
return vars or obj.vars
with patch.object(AutoToolsBuildEnvironment, 'configure', new=custom_configure):
be = AutoToolsBuildEnvironment(conanfile)
# Get vars and modify them
my_vars = be.vars
my_vars["fake_var"] = "fake"
my_vars["super_fake_var"] = "fakefake"
# TEST with default vars
mocked_result = be.configure()
self.assertEqual(mocked_result, be.vars)
# TEST with custom vars
mocked_result = be.configure(vars=my_vars)
self.assertEqual(mocked_result, my_vars)
def test_build_type_flags(self, compiler, build_type, vs_toolset, flags):
settings = MockSettings({
"compiler": compiler,
"build_type": build_type,
"compiler.toolset": vs_toolset
})
self.assertEqual(' '.join(build_type_flags(settings)), flags)
def test_build_with_custom_configuration(self):
conanfile = MockConanfile(
MockSettings({'os': 'Linux', 'compiler': 'gcc'}),
runner=RunnerMock())
conanfile.source_folder = '.'
conanfile.build_folder = '.'
build_helper = qbs.Qbs(conanfile)
config_name = 'debug'
config_values = {
'product.App.boolProperty': True,
'product.App.intProperty': 1337,
'product.App.stringProperty': 'Hello World',
'product.App.stringListProperty': ['Hello', 'World']
}
build_helper.add_configuration(config_name, config_values)
build_helper.build()
self.assertEqual(
conanfile.runner.command_called,
('qbs build --no-install --build-directory %s '
'--file %s --jobs %s profile:%s '
'config:%s %s:%s %s:%s %s:%s %s:%s') % (
conanfile.build_folder, build_helper._project_file,
build_helper.jobs, build_helper.use_toolchain_profile,
config_name,
'product.App.boolProperty',
'true',
'product.App.intProperty',
config_values['product.App.intProperty'],
'product.App.stringProperty',
config_values['product.App.stringProperty'],
'product.App.stringListProperty',
config_values['product.App.stringListProperty']))
def test_target_triple(self):
conan_file = ConanFileMock()
conan_file.deps_cpp_info = self._creat_deps_cpp_info()
conan_file.settings = MockSettings({"os_target":"Linux", "arch_target":"x86_64"})
be = AutoToolsBuildEnvironment(conan_file)
expected = "x86_64-linux-gnu"
self.assertEqual(be.target, expected)
def test_construct_build_helper_with_project_file(self):
conanfile = MockConanfile(
MockSettings({'os': 'Linux', 'compiler': 'gcc'}))
# just asume that the test is called from repo root
profile_file_path = temp_folder()
build_helper = qbs.Qbs(conanfile, project_file=profile_file_path)
self.assertEqual(build_helper._project_file, profile_file_path)
def test_warn_when_no_triplet(self):
conan_file = ConanFileMock()
conan_file.deps_cpp_info = self._creat_deps_cpp_info()
conan_file.settings = MockSettings({"arch": "UNKNOWN_ARCH", "os": "Linux"})
AutoToolsBuildEnvironment(conan_file)
self.assertIn("Unknown 'UNKNOWN_ARCH' machine, Conan doesn't know "
"how to translate it to the GNU triplet", conan_file.output)