def test_mcst_lcc(self):
runner = RunnerMock()
runner.output = "#define __LCC__ 125\n" \
"#define __LCC_MINOR__ 6\n" \
"#define __e2k__ 1\n"
compiler_id = detect_compiler_id("lcc", runner=runner)
self.assertEqual(CompilerId(MCST_LCC, 1, 25, 6), compiler_id)
def test_bad_numbers(self):
runner = RunnerMock()
runner.output = "#define __GNUC__ A\n" \
"#define __GNUC_MINOR__ B\n" \
"#define __GNUC_PATCHLEVEL__ C\n"
compiler_id = detect_compiler_id("gcc", runner=runner)
self.assertEqual(UNKNOWN_COMPILER, compiler_id)
def test_gcc(self):
runner = RunnerMock()
runner.output = "#define __GNUC__ 7\n" \
"#define __GNUC_MINOR__ 3\n" \
"#define __GNUC_PATCHLEVEL__ 0\n"
compiler_id = detect_compiler_id("gcc", runner=runner)
self.assertEqual(CompilerId(GCC, 7, 3, 0), compiler_id)
def test_qcc(self):
runner = RunnerMock()
runner.output = "#define __QNX__ 1\n" \
"#define __GNUC__ 4\n" \
"#define __GNUC_MINOR__ 2\n" \
"#define __GNUC_PATCHLEVEL__ 4\n"
compiler_id = detect_compiler_id("qcc", runner=runner)
self.assertEqual(CompilerId(QCC, 4, 2, 4), compiler_id)
def test_intel(self):
runner = RunnerMock()
# Intel C++ may define __GNUC__ and _MSC_VER for compatibility
runner.output = "#define _MSC_VER 1922\n" \
"#define __GNUC__ 4\n" \
"#define __GNUC_MINOR__ 1\n" \
"#define __GNUC_PATCHLEVEL__ 1\n" \
"#define __INTEL_COMPILER 1900\n" \
"#define __INTEL_COMPILER_UPDATE 3\n"
compiler_id = detect_compiler_id("clang", runner=runner)
self.assertEqual(CompilerId(INTEL, 19, 0, 3), compiler_id)
def test_apple_clang(self):
runner = RunnerMock()
runner.output = "#define __GNUC__ 4\n" \
"#define __GNUC_MINOR__ 1\n" \
"#define __GNUC_PATCHLEVEL__ 1\n" \
"#define __clang__ 1\n"\
"#define __clang_major__ 10\n" \
"#define __clang_minor__ 0\n" \
"#define __clang_patchlevel__ 1\n" \
"#define __apple_build_version__ 10010046\n"
compiler_id = detect_compiler_id("clang", runner=runner)
self.assertEqual(CompilerId(APPLE_CLANG, 10, 0, 1), compiler_id)
def test_clang(self):
runner = RunnerMock()
# clang defines __GNUC__ and may define _MSC_VER as well (on Windows)
runner.output = "#define _MSC_VER 1922\n" \
"#define __GNUC__ 4\n" \
"#define __GNUC_MINOR__ 1\n" \
"#define __GNUC_PATCHLEVEL__ 1\n" \
"#define __clang__ 1\n"\
"#define __clang_major__ 9\n" \
"#define __clang_minor__ 0\n" \
"#define __clang_patchlevel__ 1\n"
compiler_id = detect_compiler_id("clang", runner=runner)
self.assertEqual(CompilerId(CLANG, 9, 0, 1), compiler_id)
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_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_make_targets_install(self):
runner = RunnerMock()
conanfile = MockConanfile(MockSettings({}), None, runner)
ab = AutoToolsBuildEnvironment(conanfile)
ab.configure()
ab.make(target="install")
self.assertEqual(runner.command_called, "make install -j%s" %
cpu_count(output=conanfile.output))
ab.install()
self.assertEqual(runner.command_called, "make install -j%s" %
cpu_count(output=conanfile.output))
def test_opensuse_zypper_aptitude(self):
# https://github.com/conan-io/conan/issues/8737
os_info = OSInfo()
os_info.is_linux = True
os_info.is_solaris = False
os_info.is_macos = False
os_info.is_windows = False
os_info.linux_distro = "opensuse"
runner = RunnerMock()
with tools.environment_append({"CONAN_SYSREQUIRES_SUDO": "False"}):
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "zypper --non-interactive ref")
def verify_update_test(self):
# https://github.com/conan-io/conan/issues/3142
with tools.environment_append({"CONAN_SYSREQUIRES_SUDO": "False",
"CONAN_SYSREQUIRES_MODE": "Verify"}):
runner = RunnerMock()
# fake os info to linux debian, default sudo
os_info = OSInfo()
os_info.is_macos = False
os_info.is_linux = True
os_info.is_windows = False
os_info.linux_distro = "debian"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, None)
self.assertIn('Not updating system_requirements. CONAN_SYSREQUIRES_MODE=verify',
self.out)
def test_mocked_methods(self):
runner = RunnerMock()
conanfile = MockConanfile(MockSettings({}), None, runner)
ab = AutoToolsBuildEnvironment(conanfile)
ab.make(make_program="othermake")
self.assertEqual(runner.command_called, "othermake -j%s" %
cpu_count(output=conanfile.output))
with tools.environment_append({"CONAN_MAKE_PROGRAM": "mymake"}):
ab.make(make_program="othermake")
self.assertEqual(runner.command_called, "mymake -j%s" %
cpu_count(output=conanfile.output))
ab.make(args=["things"])
things = "'things'" if platform.system() != "Windows" else "things"
self.assertEqual(runner.command_called, "make %s -j%s" %
(things, cpu_count(output=conanfile.output)))
def system_package_tool_fail_when_not_0_returned_test(self):
def get_linux_error_message():
"""
Get error message for Linux platform if distro is supported, None otherwise
"""
os_info = OSInfo()
update_command = None
if os_info.with_apt:
update_command = "sudo -A apt-get update"
elif os_info.with_yum:
update_command = "sudo -A yum check-update -y"
elif os_info.with_dnf:
update_command = "sudo -A dnf check-update -y"
elif os_info.with_zypper:
update_command = "sudo -A zypper --non-interactive ref"
elif os_info.with_pacman:
update_command = "sudo -A pacman -Syyu --noconfirm"
return ("Command '{0}' failed".format(update_command)
if update_command is not None else None)
platform_update_error_msg = {
"Linux":
get_linux_error_message(),
"Darwin":
"Command 'brew update' failed",
"Windows":
"Command 'choco outdated' failed" if which("choco.exe") else None,
}
runner = RunnerMock(return_ok=False)
output = ConanOutput(StringIO())
pkg_tool = ChocolateyTool(
output=output) if which("choco.exe") else None
spt = SystemPackageTool(runner=runner, tool=pkg_tool, output=output)
msg = platform_update_error_msg.get(platform.system(), None)
if msg is not None:
with six.assertRaisesRegex(self, ConanException, msg):
spt.update()
else:
spt.update() # Won't raise anything because won't do anything
def test_configure_arguments():
tmp = temp_folder()
os.chdir(tmp)
save_toolchain_args({
"configure_args": "my_configure_args",
"make_args": "my_make_args"
})
runner = RunnerMock()
conanfile = ConanFile(Mock(), runner=runner)
conanfile.settings = MockSettings({})
conanfile.folders.set_base_install(tmp)
conanfile.folders.set_base_source(tmp)
conanfile.conf = Conf()
conanfile.conf["tools.gnu:make_program"] = "my_make"
conanfile.conf["tools.build:jobs"] = "23"
ab = Autotools(conanfile)
ab.configure()
assert "configure my_configure_args" in runner.command_called
ab = Autotools(conanfile)
ab.make()
assert "my_make my_make_args -j23" in runner.command_called
def test_no_output(self):
compiler_id = detect_compiler_id("gcc", runner=RunnerMock())
self.assertEqual(UNKNOWN_COMPILER, compiler_id)
def system_package_tool_test(self, patched_with_apt):
with tools.environment_append({"CONAN_SYSREQUIRES_SUDO": "True"}):
runner = RunnerMock()
# fake os info to linux debian, default sudo
os_info = OSInfo()
os_info.is_macos = False
os_info.is_linux = True
os_info.is_windows = False
patched_with_apt.return_value = True
os_info.linux_distro = "debian"
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A apt-get update")
os_info.linux_distro = "ubuntu"
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A apt-get update")
os_info.linux_distro = "knoppix"
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A apt-get update")
os_info.linux_distro = "neon"
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A apt-get update")
# We'll be testing non-Ubuntu and non-Debian-based distros.
patched_with_apt.return_value = False
with mock.patch("conans.client.tools.oss.which",
return_value=True):
os_info.linux_distro = "fedora"
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called,
"sudo -A dnf check-update -y")
# Without DNF in the path,
os_info.linux_distro = "fedora"
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called,
"sudo -A yum check-update -y")
os_info.linux_distro = "opensuse"
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called,
"sudo -A zypper --non-interactive ref")
os_info.linux_distro = "redhat"
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.install("a_package", force=False)
self.assertEqual(runner.command_called, "rpm -q a_package")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called,
"sudo -A yum install -y a_package")
settings = MockSettings({
"arch": "x86",
"arch_build": "x86_64",
"os": "Linux",
"os_build": "Linux"
})
conanfile = MockConanfile(settings)
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out,
conanfile=conanfile)
spt.install("a_package", force=False)
self.assertEqual(runner.command_called, "rpm -q a_package.i?86")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called,
"sudo -A yum install -y a_package.i?86")
os_info.linux_distro = "debian"
patched_with_apt.return_value = True
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
with self.assertRaises(ConanException):
runner.return_ok = False
spt.install("a_package")
self.assertEqual(
runner.command_called,
"sudo -A apt-get install -y --no-install-recommends a_package"
)
runner.return_ok = True
spt.install("a_package", force=False)
self.assertEqual(
runner.command_called,
'dpkg-query -W -f=\'${Status}\' a_package | grep -q "ok installed"'
)
os_info.is_macos = True
os_info.is_linux = False
os_info.is_windows = False
patched_with_apt.return_value = False
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called, "brew update")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "brew install a_package")
os_info.is_freebsd = True
os_info.is_macos = False
patched_with_apt.return_value = False
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A pkg update")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called,
"sudo -A pkg install -y a_package")
spt.install("a_package", force=False)
self.assertEqual(runner.command_called, "pkg info a_package")
# Chocolatey is an optional package manager on Windows
if platform.system() == "Windows" and which("choco.exe"):
os_info.is_freebsd = False
os_info.is_windows = True
patched_with_apt.return_value = False
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out,
tool=ChocolateyTool(output=self.out))
spt.update()
self.assertEqual(runner.command_called, "choco outdated")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called,
"choco install --yes a_package")
spt.install("a_package", force=False)
self.assertEqual(
runner.command_called,
'choco search --local-only --exact a_package | '
'findstr /c:"1 packages installed."')
with tools.environment_append({"CONAN_SYSREQUIRES_SUDO": "False"}):
os_info = OSInfo()
os_info.is_linux = True
os_info.linux_distro = "redhat"
patched_with_apt.return_value = False
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "yum install -y a_package")
spt.update()
self.assertEqual(runner.command_called, "yum check-update -y")
os_info.linux_distro = "ubuntu"
patched_with_apt.return_value = True
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.install("a_package", force=True)
self.assertEqual(
runner.command_called,
"apt-get install -y --no-install-recommends a_package")
spt.update()
self.assertEqual(runner.command_called, "apt-get update")
for arch, distro_arch in {
"x86_64": "",
"x86": ":i386",
"ppc32": ":powerpc",
"ppc64le": ":ppc64el",
"armv7": ":arm",
"armv7hf": ":armhf",
"armv8": ":arm64",
"s390x": ":s390x"
}.items():
settings = MockSettings({
"arch": arch,
"arch_build": "x86_64",
"os": "Linux",
"os_build": "Linux"
})
conanfile = MockConanfile(settings)
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out,
conanfile=conanfile)
spt.install("a_package", force=True)
self.assertEqual(
runner.command_called,
"apt-get install -y --no-install-recommends a_package%s" %
distro_arch)
for arch, distro_arch in {"x86_64": "", "x86": ":all"}.items():
settings = MockSettings({
"arch": arch,
"arch_build": "x86_64",
"os": "Linux",
"os_build": "Linux"
})
conanfile = MockConanfile(settings)
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out,
conanfile=conanfile)
spt.install("a_package", force=True, arch_names={"x86": "all"})
self.assertEqual(
runner.command_called,
"apt-get install -y --no-install-recommends a_package%s" %
distro_arch)
os_info.is_macos = True
os_info.is_linux = False
os_info.is_windows = False
patched_with_apt.return_value = False
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called, "brew update")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "brew install a_package")
os_info.is_freebsd = True
os_info.is_macos = False
os_info.is_windows = False
patched_with_apt.return_value = False
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called, "pkg update")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "pkg install -y a_package")
spt.install("a_package", force=False)
self.assertEqual(runner.command_called, "pkg info a_package")
os_info.is_solaris = True
os_info.is_freebsd = False
os_info.is_windows = False
patched_with_apt.return_value = False
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out)
spt.update()
self.assertEqual(runner.command_called, "pkgutil --catalog")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called,
"pkgutil --install --yes a_package")
with tools.environment_append({"CONAN_SYSREQUIRES_SUDO": "True"}):
# Chocolatey is an optional package manager on Windows
if platform.system() == "Windows" and which("choco.exe"):
os_info.is_solaris = False
os_info.is_windows = True
patched_with_apt.return_value = False
spt = SystemPackageTool(runner=runner,
os_info=os_info,
output=self.out,
tool=ChocolateyTool(output=self.out))
spt.update()
self.assertEqual(runner.command_called, "choco outdated")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called,
"choco install --yes a_package")
spt.install("a_package", force=False)
self.assertEqual(
runner.command_called,
'choco search --local-only --exact a_package | '
'findstr /c:"1 packages installed."')
def test_suncc(self):
runner = RunnerMock()
runner.output = "#define __SUNPRO_CC 0x450\n"
compiler_id = detect_compiler_id("suncc", runner=runner)
self.assertEqual(CompilerId(SUNCC, 4, 5, 0), compiler_id)
def system_package_tool_test(self):
with tools.environment_append({"CONAN_SYSREQUIRES_SUDO": "True"}):
runner = RunnerMock()
# fake os info to linux debian, default sudo
os_info = OSInfo()
os_info.is_macos = False
os_info.is_linux = True
os_info.is_windows = False
os_info.linux_distro = "debian"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A apt-get update")
os_info.linux_distro = "ubuntu"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A apt-get update")
os_info.linux_distro = "knoppix"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A apt-get update")
os_info.linux_distro = "neon"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A apt-get update")
os_info.linux_distro = "fedora"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A yum update -y")
os_info.linux_distro = "opensuse"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A zypper --non-interactive ref")
os_info.linux_distro = "redhat"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.install("a_package", force=False)
self.assertEqual(runner.command_called, "rpm -q a_package")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "sudo -A yum install -y a_package")
os_info.linux_distro = "debian"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
with self.assertRaises(ConanException):
runner.return_ok = False
spt.install("a_package")
self.assertEqual(runner.command_called,
"sudo -A apt-get install -y --no-install-recommends a_package")
runner.return_ok = True
spt.install("a_package", force=False)
self.assertEqual(runner.command_called,
'dpkg-query -W -f=\'${Status}\' a_package | grep -q "ok installed"')
os_info.is_macos = True
os_info.is_linux = False
os_info.is_windows = False
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "brew update")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "brew install a_package")
os_info.is_freebsd = True
os_info.is_macos = False
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "sudo -A pkg update")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "sudo -A pkg install -y a_package")
spt.install("a_package", force=False)
self.assertEqual(runner.command_called, "pkg info a_package")
# Chocolatey is an optional package manager on Windows
if platform.system() == "Windows" and which("choco.exe"):
os_info.is_freebsd = False
os_info.is_windows = True
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out,
tool=ChocolateyTool(output=self.out))
spt.update()
self.assertEqual(runner.command_called, "choco outdated")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "choco install --yes a_package")
spt.install("a_package", force=False)
self.assertEqual(runner.command_called,
'choco search --local-only --exact a_package | '
'findstr /c:"1 packages installed."')
with tools.environment_append({"CONAN_SYSREQUIRES_SUDO": "False"}):
os_info = OSInfo()
os_info.is_linux = True
os_info.linux_distro = "redhat"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "yum install -y a_package")
spt.update()
self.assertEqual(runner.command_called, "yum update -y")
os_info.linux_distro = "ubuntu"
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.install("a_package", force=True)
self.assertEqual(runner.command_called,
"apt-get install -y --no-install-recommends a_package")
spt.update()
self.assertEqual(runner.command_called, "apt-get update")
os_info.is_macos = True
os_info.is_linux = False
os_info.is_windows = False
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "brew update")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "brew install a_package")
os_info.is_freebsd = True
os_info.is_macos = False
os_info.is_windows = False
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "pkg update")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "pkg install -y a_package")
spt.install("a_package", force=False)
self.assertEqual(runner.command_called, "pkg info a_package")
os_info.is_solaris = True
os_info.is_freebsd = False
os_info.is_windows = False
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out)
spt.update()
self.assertEqual(runner.command_called, "pkgutil --catalog")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "pkgutil --install --yes a_package")
with tools.environment_append({"CONAN_SYSREQUIRES_SUDO": "True"}):
# Chocolatey is an optional package manager on Windows
if platform.system() == "Windows" and which("choco.exe"):
os_info.is_solaris = False
os_info.is_windows = True
spt = SystemPackageTool(runner=runner, os_info=os_info, output=self.out,
tool=ChocolateyTool(output=self.out))
spt.update()
self.assertEqual(runner.command_called, "choco outdated")
spt.install("a_package", force=True)
self.assertEqual(runner.command_called, "choco install --yes a_package")
spt.install("a_package", force=False)
self.assertEqual(runner.command_called,
'choco search --local-only --exact a_package | '
'findstr /c:"1 packages installed."')
def test_msvc(self, line, major, minor, patch):
runner = RunnerMock()
runner.output = line
compiler_id = detect_compiler_id("cl", runner=runner)
self.assertEqual(CompilerId(MSVC, major, minor, patch), compiler_id)
def test_msvc(self):
runner = RunnerMock()
runner.output = "MSC_CMD_FLAGS=-D_MSC_VER=1930"
compiler_id = detect_compiler_id("cl", runner=runner)
self.assertEqual(CompilerId(MSVC, 19, 30, 0), compiler_id)
def test_incomplete(self):
runner = RunnerMock()
runner.output = "#define __GNUC__ 7"
compiler_id = detect_compiler_id("gcc", runner=runner)
self.assertEqual(UNKNOWN_COMPILER, compiler_id)
def test_bad_output(self):
runner = RunnerMock()
runner.output = "#define UNKNOWN 1"
compiler_id = detect_compiler_id("gcc", runner=runner)
self.assertEqual(UNKNOWN_COMPILER, compiler_id)
def test_visual_studio(self, line, major, minor, patch):
runner = RunnerMock()
runner.output = line
compiler_id = detect_compiler_id("cl", runner=runner)
self.assertEqual(CompilerId(VISUAL_STUDIO, major, minor, patch), compiler_id)
