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_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 cross_build_command_test(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_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 _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 autotools_prefix_test(self):
runner = RunnerMock()
conanfile = MockConanfile(MockSettings({}), None, runner)
# Package folder is not defined
ab = AutoToolsBuildEnvironment(conanfile)
ab.configure()
self.assertNotIn("--prefix", runner.command_called)
# package folder defined
conanfile.package_folder = "/package_folder"
ab.configure()
if platform.system() == "Windows":
self.assertIn("./configure --prefix=/package_folder",
runner.command_called)
else:
self.assertIn("./configure '--prefix=/package_folder'",
runner.command_called)
# --prefix already used in args
ab.configure(args=["--prefix=/my_package_folder"])
if platform.system() == "Windows":
self.assertIn("./configure --prefix=/my_package_folder",
runner.command_called)
self.assertNotIn("--prefix=/package_folder", runner.command_called)
else:
self.assertIn("./configure '--prefix=/my_package_folder'",
runner.command_called)
self.assertNotIn("'--prefix=/package_folder'",
runner.command_called)
def test_freebsd(self):
with mock.patch("platform.system", mock.MagicMock(return_value='FreeBSD')), \
mock.patch("platform.machine", mock.MagicMock(return_value="x86_64")):
settings = MockSettings({})
build_os, build_arch, _, _ = get_cross_building_settings(settings)
self.assertEqual("FreeBSD", build_os)
self.assertEqual("x86_64", build_arch)
def get_values(this_os, this_arch, setting_os, setting_arch):
settings = MockSettings({"arch": setting_arch,
"os": setting_os})
conanfile = MockConanfile(settings)
conanfile.settings = settings
be = AutoToolsBuildEnvironment(conanfile)
return be._get_host_build_target_flags(this_arch, this_os)
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:Platform="ARM" '
'/p:PlatformToolset="v110" '
'/verbosity:minimal '
'/p:ForceImportBeforeCppTargets='), command)
def test_negative(self):
self.assertIsNone(
tools.msvs_toolset(
MockSettings({
"compiler": "Visual Studio",
"compiler.version": "666"
})))
def test_check_cppstd_type(self):
""" cppstd must be a number
"""
conanfile = MockConanfile(MockSettings({}))
with self.assertRaises(ConanException) as raises:
check_min_cppstd(conanfile, "gnu17", False)
self.assertEqual("cppstd parameter must be a number", str(raises.exception))
def properties_file_test(self):
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)
self.assertTrue(
command.startswith('msbuild "dummy.sln" /p:Configuration="Debug" '
'/p:Platform="ARM" '
'/p:ForceImportBeforeCppTargets='), command)
path_tmp = command.split("/p:ForceImportBeforeCppTargets=")[1][
1:-1] # remove quotes
self.assertTrue(os.path.exists(path_tmp))
contents = load(path_tmp)
self.assertIn("<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>",
contents)
self.assertIn(
"<AdditionalOptions>/std:c++17 %(AdditionalOptions)</AdditionalOptions>",
contents)
def skip_toolset_test(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 setUpClass(cls):
conanfile = ConanFileMock()
conanfile.settings = MockSettings({"compiler": "gcc",
"build_type": "Release"})
cls.generator = VirtualBuildEnvGenerator(conanfile)
cls.result = cls.generator.content
def modify_values_test(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_cpp_flag -onlycxx',
'LDFLAGS':
'-inventedflag -Lone/lib/path',
'LIBS':
'-lonelib -ltwolib'
}
self.assertEquals(be.vars, expected)
def rpath_optin_test(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_cpp_flag',
'LDFLAGS':
'shared_link_flag exe_link_flag -m64 --sysroot=/path/to/folder '
'-Wl,-rpath="one/lib/path" -Lone/lib/path',
'LIBS':
'-lonelib -ltwolib'
}
be = AutoToolsBuildEnvironment(conanfile, include_rpath_flags=True)
self.assertEquals(be.vars, expected)
def environment_append_test(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_cpp_flag -additionalcxxflag',
'LIBS':
'-lonelib -ltwolib -additionallibs',
'LDFLAGS':
'shared_link_flag exe_link_flag -m64 '
'--sysroot=/path/to/folder -Lone/lib/path -additionalldflag',
'CFLAGS':
'a_c_flag -m64 -g --sysroot=/path/to/folder -additionalcflag'
}
self.assertEquals(be.vars, expected)
def autotools_configure_vars_test(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_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_previous_env(self):
settings = MockSettings({"arch": "x86", "os": "Linux"})
conanfile = MockConanfile(settings)
with tools.environment_append({"CPPFLAGS": "MyCppFlag"}):
be = AutoToolsBuildEnvironment(conanfile)
self.assertEquals(be.vars["CPPFLAGS"], "MyCppFlag")
def properties_file_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, 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" '
'/verbosity:minimal '
'/p:ForceImportBeforeCppTargets='), command)
path_tmp = command.split("/p:ForceImportBeforeCppTargets=")[1][1:-1] # remove quotes
self.assertTrue(os.path.exists(path_tmp))
contents = load(path_tmp)
self.assertIn("<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>", contents)
self.assertIn("<AdditionalOptions>/std:c++17 %(AdditionalOptions)</AdditionalOptions>",
contents)
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 autotools_install_dirs_test(self):
runner = RunnerMockWithHelp(available_args=default_dirs_flags)
conanfile = MockConanfileWithOutput(MockSettings({}), None, runner)
# Package folder is not defined
ab = AutoToolsBuildEnvironment(conanfile)
ab.configure()
self.assertNotIn("--prefix", runner.command_called)
self.assertNotIn("--bindir", runner.command_called)
self.assertNotIn("--libdir", runner.command_called)
self.assertNotIn("--includedir", runner.command_called)
self.assertNotIn("--dataroot", runner.command_called)
# package folder defined
conanfile.package_folder = "/package_folder"
ab.configure()
if platform.system() == "Windows":
self.assertIn(
"./configure --prefix=/package_folder --bindir=${prefix}/bin "
"--sbin=${prefix}/bin --libexec=${prefix}/bin --libdir=${prefix}/lib "
"--includedir=${prefix}/include --oldincludedir=${prefix}/include "
"--datarootdir=${prefix}/res", runner.command_called)
else:
self.assertIn(
"./configure '--prefix=/package_folder' '--bindir=${prefix}/bin' "
"'--sbin=${prefix}/bin' '--libexec=${prefix}/bin' '--libdir=${prefix}/lib' "
"'--includedir=${prefix}/include' '--oldincludedir=${prefix}/include' "
"'--datarootdir=${prefix}/res'", runner.command_called)
# --prefix already used in args
ab.configure(args=["--prefix=/my_package_folder"])
self.assertIn("--prefix=/my_package_folder", runner.command_called)
self.assertNotIn("--prefix=/package_folder", runner.command_called)
# --bindir, --libdir, --includedir already used in args
ab.configure(args=[
"--bindir=/pf/superbindir", "--libdir=/pf/superlibdir",
"--includedir=/pf/superincludedir"
])
self.assertNotIn("--bindir=${prefix}/bin", runner.command_called)
self.assertNotIn("--libdir=${prefix}/lib", runner.command_called)
self.assertNotIn("--includedir=${prefix}/lib", runner.command_called)
if platform.system() == "Windows":
self.assertIn(
"./configure --bindir=/pf/superbindir --libdir=/pf/superlibdir "
"--includedir=/pf/superincludedir --prefix=/package_folder "
"--sbin=${prefix}/bin --libexec=${prefix}/bin "
"--oldincludedir=${prefix}/include --datarootdir=${prefix}/res",
runner.command_called)
else:
self.assertIn(
"./configure '--bindir=/pf/superbindir' '--libdir=/pf/superlibdir' "
"'--includedir=/pf/superincludedir' '--prefix=/package_folder' "
"'--sbin=${prefix}/bin' '--libexec=${prefix}/bin' "
"'--oldincludedir=${prefix}/include' '--datarootdir=${prefix}/res'",
runner.command_called)
# opt-out from default installation dirs
ab.configure(use_default_install_dirs=False)
self.assertIn("--prefix=/package_folder", runner.command_called)
self.assertNotIn("--bindir=${prefix}/bin", runner.command_called)
self.assertNotIn("--libdir=${prefix}/lib", runner.command_called)
self.assertNotIn("--includedir=${prefix}/lib", runner.command_called)
def test_linux(self):
with mock.patch("platform.system", mock.MagicMock(return_value='Linux')), \
mock.patch("platform.machine", mock.MagicMock(return_value="x86_64")), \
mock.patch.object(OSInfo, '_get_linux_distro_info'):
conanfile = MockConanfile(MockSettings({}))
build_os, build_arch, _, _ = get_cross_building_settings(conanfile)
self.assertEqual("Linux", build_os)
self.assertEqual("x86_64", build_arch)
def verbosity_explicit_test(self):
settings = MockSettings({"build_type": "Debug",
"compiler": "Visual Studio",
"arch": "x86_64"})
conanfile = MockConanfile(settings)
msbuild = MSBuild(conanfile)
command = msbuild.get_command("projecshould_flags_testt_file.sln", verbosity="quiet")
self.assertIn('/verbosity:quiet', command)
def without_runtime_test(self):
settings = MockSettings({"build_type": "Debug",
"compiler": "Visual Studio",
"arch": "x86_64"})
conanfile = MockConanfile(settings)
msbuild = MSBuild(conanfile)
template = msbuild._get_props_file_contents()
self.assertNotIn("<RuntimeLibrary>", template)
def target_triple_test(self):
conan_file = ConanFileMock()
deps_cpp_info = namedtuple("Deps", "libs, include_paths, lib_paths, defines, cflags, "
"cxxflags, sharedlinkflags, exelinkflags, sysroot")
conan_file.deps_cpp_info = 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_mingw64(self):
with mock.patch("platform.system", mock.MagicMock(return_value='MINGW64_NT-10.0')), \
mock.patch("platform.machine", mock.MagicMock(return_value="x86_64")), \
mock.patch.object(OSInfo, "get_win_version_name", return_value="Windows 98"), \
mock.patch.object(OSInfo, "get_win_os_version", return_value="4.0"):
conanfile = MockConanfile(MockSettings({}))
build_os, build_arch, _, _ = get_cross_building_settings(conanfile)
self.assertEqual("Windows", build_os)
self.assertEqual("x86_64", build_arch)
def test_cygwin(self):
with mock.patch("platform.system", mock.MagicMock(return_value='CYGWIN_NT-10.0')), \
mock.patch("platform.machine", mock.MagicMock(return_value="x86_64")), \
mock.patch.object(OSInfo, "get_win_version_name", return_value="Windows 98"), \
mock.patch.object(OSInfo, "get_win_os_version", return_value="4.0"):
settings = MockSettings({})
build_os, build_arch, _, _ = get_cross_building_settings(settings)
self.assertEqual("Windows", build_os)
self.assertEqual("x86_64", build_arch)
def warn_when_no_triplet_test(self):
conan_file = ConanFileMock()
deps_cpp_info = namedtuple("Deps", "libs, include_paths, lib_paths, defines, cflags, "
"cxxflags, sharedlinkflags, exelinkflags, sysroot")
conan_file.deps_cpp_info = 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)