def detect_file_profile_test(self, _):
output = TestBufferConanOutput()
with tools.environment_append({"CC": "gcc"}):
detect_defaults_settings(output, profile_path="./MyProfile")
self.assertIn(
"conan profile update settings.compiler.libcxx=libstdc++11 MyProfile",
output)
def detect_default_profile_test(self, _):
output = TestBufferConanOutput()
with tools.environment_append({"CC": "gcc"}):
detect_defaults_settings(output,
profile_path="~/.conan/profiles/default")
self.assertIn("edit the default profile at", output)
self.assertIn("~/.conan/profiles/default", output)
def detect_abs_file_profile_test(self, _):
output = TestBufferConanOutput()
with tools.environment_append({"CC": "gcc"}):
detect_defaults_settings(
output, profile_path="/foo/bar/quz/custom-profile")
self.assertIn("edit the custom-profile profile at", output)
self.assertIn("/foo/bar/quz/custom-profile", output)
def test_detect_abs_file_profile(self, _):
output = TestBufferConanOutput()
with tools.environment_append({"CC": "gcc"}):
detect_defaults_settings(
output, profile_path="/foo/bar/quz/custom-profile")
self.assertIn(
"conan profile update settings.compiler.libcxx=libstdc++11 "
"custom-profile", output)
def cmd_profile_create(profile_name,
cache_profiles_path,
output,
detect=False):
profile_path = get_profile_path(profile_name,
cache_profiles_path,
get_cwd(),
exists=False)
if os.path.exists(profile_path):
raise ConanException("Profile already exists")
profile = Profile()
if detect:
settings = detect_defaults_settings(output)
for name, value in settings:
profile.settings[name] = value
contents = profile.dumps()
save(profile_path, contents)
if detect:
output.info("Profile created with detected settings: %s" %
profile_path)
else:
output.info("Empty profile created: %s" % profile_path)
return profile_path
def test_detect_arch(self, machine, expected_arch):
with mock.patch("platform.machine", mock.MagicMock(return_value=machine)):
result = detect_defaults_settings(output=Mock(),
profile_path=DEFAULT_PROFILE_NAME)
result = dict(result)
self.assertEqual(expected_arch, result['arch'])
self.assertEqual(expected_arch, result['arch_build'])
def detect_test(self):
output = TestBufferConanOutput()
result = detect_defaults_settings(output)
if platform.system() == "Linux":
for (name, value) in result:
if name == "compiler":
self.assertEquals(value, "gcc")
def detect_default_in_mac_os_using_gcc_as_default_test(self):
"""
Test if gcc in Mac OS X is using apple-clang as frontend
"""
# See: https://github.com/conan-io/conan/issues/2231
try:
output = check_output(["gcc", "--version"],
stderr=subprocess.STDOUT)
except subprocess.CalledProcessError:
# gcc is not installed or there is any error (no test scenario)
return
if "clang" not in output:
# Not test scenario gcc should display clang in output
# see: https://stackoverflow.com/questions/19535422/os-x-10-9-gcc-links-to-clang
raise Exception(
"Apple gcc doesn't point to clang with gcc frontend anymore!")
output = TestBufferConanOutput()
with tools.environment_append({"CC": "gcc"}):
result = detect_defaults_settings(
output, profile_path=DEFAULT_PROFILE_NAME)
# result is a list of tuples (name, value) so converting it to dict
result = dict(result)
# No compiler should be detected
self.assertIsNone(result.get("compiler", None))
self.assertIn("gcc detected as a frontend using apple-clang", output)
self.assertIsNotNone(output.error)
def default_profile(self):
if self._default_profile is None:
if not os.path.exists(self.default_profile_path):
self._output.writeln(
"Auto detecting your dev setup to initialize the "
"default profile (%s)" % self.default_profile_path,
Color.BRIGHT_YELLOW)
default_settings = detect_defaults_settings(self._output)
self._output.writeln("Default settings", Color.BRIGHT_YELLOW)
self._output.writeln(
"\n".join(
["\t%s=%s" % (k, v) for (k, v) in default_settings]),
Color.BRIGHT_YELLOW)
self._output.writeln(
"*** You can change them in %s ***" %
self.default_profile_path, Color.BRIGHT_MAGENTA)
self._output.writeln(
"*** Or override with -s compiler='other' -s ...s***\n\n",
Color.BRIGHT_MAGENTA)
self._default_profile = Profile()
tmp = OrderedDict(default_settings)
self._default_profile.update_settings(tmp)
save(self.default_profile_path, self._default_profile.dumps())
else:
self._default_profile, _ = read_profile(
self.default_profile_path, get_cwd(), self.profiles_path)
# Mix profile settings with environment
mixed_settings = _mix_settings_with_env(
self._default_profile.settings)
self._default_profile.settings = mixed_settings
return self._default_profile
def detect_default_in_mac_os_using_gcc_as_default_test(self):
"""
Test if gcc in Mac OS X is using apple-clang as frontend
"""
# See: https://github.com/conan-io/conan/issues/2231
if platform.system() != "Darwin":
return
try:
output = subprocess.check_output(["gcc", "--version"], stderr=subprocess.STDOUT)
except subprocess.CalledProcessError:
# gcc is not installed or there is any error (no test scenario)
return
if b"clang" not in output:
# Not test scenario gcc should display clang in output
# see: https://stackoverflow.com/questions/19535422/os-x-10-9-gcc-links-to-clang
raise Exception("Apple gcc doesn't point to clang with gcc frontend anymore! please check")
output = TestBufferConanOutput()
with tools.environment_append({"CC": "gcc"}):
result = detect_defaults_settings(output)
# result is a list of tuples (name, value) so converting it to dict
result = dict(result)
# No compiler should be detected
self.assertIsNone(result.get("compiler", None))
self.assertIn("gcc detected as a frontend using apple-clang", output)
self.assertIsNotNone(output.error)
def test_vs2022(self):
with mock.patch("conans.client.conf.detect._get_default_compiler",
mock.MagicMock(return_value=("Visual Studio", "17"))):
result = detect_defaults_settings(
output=Mock(), profile_path=DEFAULT_PROFILE_NAME)
result = dict(result)
self.assertEqual('msvc', result['compiler'])
self.assertEqual('19.3', result['compiler.version'])
def test_detect_default_compilers(self):
platform_default_compilers = {
"Linux": "gcc",
"Darwin": "apple-clang",
"Windows": "Visual Studio"
}
output = TestBufferConanOutput()
result = detect_defaults_settings(output, profile_path=DEFAULT_PROFILE_NAME)
# result is a list of tuples (name, value) so converting it to dict
result = dict(result)
platform_compiler = platform_default_compilers.get(platform.system(), None)
if platform_compiler is not None:
self.assertEqual(result.get("compiler", None), platform_compiler)
def test_detect_aix(self, processor, bitness, version, expected_arch):
with mock.patch("platform.machine", mock.MagicMock(return_value='XXXXXXXXXXXX')), \
mock.patch("platform.processor", mock.MagicMock(return_value=processor)), \
mock.patch("platform.system", mock.MagicMock(return_value='AIX')), \
mock.patch("conans.client.tools.oss.OSInfo.get_aix_conf", mock.MagicMock(return_value=bitness)), \
mock.patch('subprocess.check_output', mock.MagicMock(return_value=version)):
result = detect_defaults_settings(
output=Mock(), profile_path=DEFAULT_PROFILE_NAME)
result = dict(result)
self.assertEqual("AIX", result['os'])
self.assertEqual("AIX", result['os_build'])
self.assertEqual(expected_arch, result['arch'])
self.assertEqual(expected_arch, result['arch_build'])
def detect_default_compilers_test(self):
platform_default_compilers = {
"Linux": "gcc",
"Darwin": "apple-clang",
"Windows": "Visual Studio"
}
output = TestBufferConanOutput()
result = detect_defaults_settings(output)
# result is a list of tuples (name, value) so converting it to dict
result = dict(result)
platform_compiler = platform_default_compilers.get(platform.system(), None)
if platform_compiler is not None:
self.assertEquals(result.get("compiler", None), platform_compiler)
def create_profile(self, profile_name, detect=False):
profile_path = get_profile_path(profile_name, self._client_cache.profiles_path, os.getcwd(),
exists=False)
if os.path.exists(profile_path):
raise ConanException("Profile already exists")
profile = Profile()
if detect:
settings = detect_defaults_settings(self._user_io.out)
for name, value in settings:
profile.settings[name] = value
contents = profile.dumps()
save(profile_path, contents)
self._user_io.out.info("Empty profile created: %s" % profile_path)
return profile_path
def initialize_default_profile(self):
if not os.path.exists(self.default_profile_path):
self._output.writeln("Auto detecting your dev setup to initialize the "
"default profile (%s)" % self.default_profile_path,
Color.BRIGHT_YELLOW)
default_settings = detect_defaults_settings(self._output,
profile_path=self.default_profile_path)
self._output.writeln("Default settings", Color.BRIGHT_YELLOW)
self._output.writeln("\n".join(["\t%s=%s" % (k, v) for (k, v) in default_settings]),
Color.BRIGHT_YELLOW)
self._output.writeln("*** You can change them in %s ***" % self.default_profile_path,
Color.BRIGHT_MAGENTA)
self._output.writeln("*** Or override with -s compiler='other' -s ...s***\n\n",
Color.BRIGHT_MAGENTA)
default_profile = Profile()
tmp = OrderedDict(default_settings)
default_profile.update_settings(tmp)
save(self.default_profile_path, default_profile.dumps())
def cmd_profile_create(profile_name, cache_profiles_path, output, detect=False):
profile_path = get_profile_path(profile_name, cache_profiles_path, get_cwd(),
exists=False)
if os.path.exists(profile_path):
raise ConanException("Profile already exists")
profile = Profile()
if detect:
settings = detect_defaults_settings(output)
for name, value in settings:
profile.settings[name] = value
contents = profile.dumps()
save(profile_path, contents)
if detect:
output.info("Profile created with detected settings: %s" % profile_path)
else:
output.info("Empty profile created: %s" % profile_path)
return profile_path
def env_setting_override_test(self):
tmp_dir = temp_folder()
out = MockOut()
cache = ClientCache(tmp_dir, None, out)
base_settings = OrderedDict(
detect_defaults_settings(out,
profile_path="~/.conan/profiles/default"))
with tools.environment_append({"CONAN_ENV_COMPILER_VERSION": "4.6"}):
expected = copy.copy(base_settings)
expected["compiler.version"] = "4.6"
self.assertEqual(cache.default_profile.settings, expected)
tmp_dir = temp_folder()
cache = ClientCache(tmp_dir, None, out)
with tools.environment_append({}):
self.assertEqual(cache.default_profile.settings, base_settings)
tmp_dir = temp_folder()
cache = ClientCache(tmp_dir, None, out)
# If compiler is overwritten compiler subsettings are not assigned
with tools.environment_append({"CONAN_ENV_COMPILER": "Visual Studio"}):
expected = copy.copy(base_settings)
expected["compiler"] = "Visual Studio"
self.assertEqual(cache.default_profile.settings, expected)
tmp_dir = temp_folder()
cache = ClientCache(tmp_dir, None, out)
with tools.environment_append({
"CONAN_ENV_COMPILER": "Visual Studio",
"CONAN_ENV_COMPILER_VERSION": "14",
"CONAN_ENV_COMPILER_RUNTIME": "MDd"
}):
expected = copy.copy(base_settings)
expected["compiler"] = "Visual Studio"
expected["compiler.runtime"] = "MDd"
expected["compiler.version"] = "14"
self.assertEqual(cache.default_profile.settings, expected)
def env_setting_override_test(self):
tmp_dir = temp_folder()
out = MockOut()
cache = ClientCache(tmp_dir, None, out)
base_settings = OrderedDict(detect_defaults_settings(out))
with tools.environment_append({"CONAN_ENV_COMPILER_VERSION": "4.6"}):
expected = copy.copy(base_settings)
expected["compiler.version"] = "4.6"
self.assertEquals(cache.default_profile.settings, expected)
tmp_dir = temp_folder()
cache = ClientCache(tmp_dir, None, out)
with tools.environment_append({}):
self.assertEquals(cache.default_profile.settings, base_settings)
tmp_dir = temp_folder()
cache = ClientCache(tmp_dir, None, out)
# If compiler is overwritten compiler subsettings are not assigned
with tools.environment_append({"CONAN_ENV_COMPILER": "Visual Studio"}):
expected = copy.copy(base_settings)
expected["compiler"] = "Visual Studio"
self.assertEquals(cache.default_profile.settings, expected)
tmp_dir = temp_folder()
cache = ClientCache(tmp_dir, None, out)
with tools.environment_append({"CONAN_ENV_COMPILER": "Visual Studio",
"CONAN_ENV_COMPILER_VERSION": "14",
"CONAN_ENV_COMPILER_RUNTIME": "MDd"}):
expected = copy.copy(base_settings)
expected["compiler"] = "Visual Studio"
expected["compiler.runtime"] = "MDd"
expected["compiler.version"] = "14"
self.assertEquals(cache.default_profile.settings, expected)
def test_detect_empty_arch(self, _):
result = detect_defaults_settings(output=TestBufferConanOutput())
result = dict(result)
self.assertTrue("arch" not in result)
self.assertTrue("arch_build" not in result)
def test_detect_clang_gcc_toolchain(self, _):
output = TestBufferConanOutput()
with tools.environment_append(
{"CC": "clang-9 --gcc-toolchain=/usr/lib/gcc/x86_64-linux-gnu/9"}):
detect_defaults_settings(output, profile_path="./MyProfile")
self.assertIn("CC and CXX: clang-9 --gcc-toolchain", output)
def test_detect_empty_arch(self, _):
result = detect_defaults_settings(output=TestBufferConanOutput(),
profile_path=DEFAULT_PROFILE_NAME)
result = dict(result)
self.assertTrue("arch" not in result)
self.assertTrue("arch_build" not in result)
