def test_frameworks(self):
conanfile = ConanFile(Mock(), None)
conanfile.initialize(Settings({}), EnvValues())
framework_path = os.getcwd(
) # must exist, otherwise filtered by framework_paths
cpp_info = CppInfo("MyPkg", "/rootpath")
cpp_info.frameworks = ["HelloFramework"]
cpp_info.frameworkdirs = [framework_path]
conanfile.deps_cpp_info.add("MyPkg", DepCppInfo(cpp_info))
generator = QmakeGenerator(conanfile)
content = generator.content
qmake_lines = content.splitlines()
self.assertIn('CONAN_FRAMEWORKS += -framework HelloFramework',
qmake_lines)
self.assertIn('CONAN_FRAMEWORK_PATHS += -F%s' % framework_path,
qmake_lines)
def test_abs_path_unix(self):
conanfile = ConanFile(Mock(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("pkg/0.1")
cpp_info = CppInfo(ref.name, "/rootdir")
cpp_info.includedirs = ["/an/absolute/dir"]
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add(ref.name, cpp_info)
master_content = TXTGenerator(conanfile).content
after_cpp_info, _, _, _ = TXTGenerator.loads(master_content,
filter_empty=False)
self.assertListEqual(after_cpp_info[ref.name].includedirs,
["../an/absolute/dir"])
self.assertListEqual(after_cpp_info[ref.name].include_paths,
["/rootdir/../an/absolute/dir"])
def test_absolute_directory(self):
conanfile = ConanFile(Mock(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("pkg/0.1")
cpp_info = CppInfo(ref.name, "C:/my/root/path")
cpp_info.includedirs = ["D:/my/path/to/something"]
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add(ref.name, cpp_info)
master_content = TXTGenerator(conanfile).content
after_cpp_info, _, _, _ = TXTGenerator.loads(master_content,
filter_empty=False)
self.assertListEqual(after_cpp_info[ref.name].includedirs,
["D:/my/path/to/something"])
self.assertListEqual(after_cpp_info[ref.name].include_paths,
["D:/my/path/to/something"])
def validate_additional_dependencies(lib, additional_dep):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@user/testing")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.libs = [lib]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = VisualStudioGenerator(conanfile)
content = generator.content
self.assertIn(
"<ConanLibraries>%s;</ConanLibraries>" % additional_dep,
content)
self.assertIn(
"<AdditionalDependencies>"
"$(ConanLibraries)%(AdditionalDependencies)"
"</AdditionalDependencies>", content)
def _get_graph(self, reference, current_path, remote, options, settings, filename, update,
check_updates, manifest_manager, scopes, package_settings, env_values):
loader = self._loader(current_path, settings, package_settings, options,
scopes, env_values, use_conaninfo=False)
# Not check for updates for info command, it'll be checked when dep graph is built
remote_proxy = ConanProxy(self._client_cache, self._user_io, self._remote_manager, remote,
update=update, check_updates=check_updates,
manifest_manager=manifest_manager)
if isinstance(reference, ConanFileReference):
project_reference = None
conanfile = loader.load_virtual(reference, current_path)
is_txt = True
else:
conanfile_path = reference
project_reference = "PROJECT"
output = ScopedOutput(project_reference, self._user_io.out)
try:
if filename and filename.endswith(".txt"):
raise NotFoundException("")
conan_file_path = os.path.join(conanfile_path, filename or CONANFILE)
conanfile = loader.load_conan(conan_file_path, output, consumer=True)
is_txt = False
if conanfile.name is not None and conanfile.version is not None:
project_reference = "%s/%s@" % (conanfile.name, conanfile.version)
project_reference += "PROJECT"
except NotFoundException: # Load conanfile.txt
conan_path = os.path.join(conanfile_path, filename or CONANFILE_TXT)
conanfile = loader.load_conan_txt(conan_path, output)
is_txt = True
# build deps graph and install it
local_search = None if update else self._search_manager
resolver = RequireResolver(self._user_io.out, local_search, remote_proxy)
builder = DepsGraphBuilder(remote_proxy, self._user_io.out, loader, resolver)
deps_graph = builder.load(None, conanfile)
# These lines are so the conaninfo stores the correct complete info
if is_txt:
conanfile.info.settings = loader._settings.values
conanfile.info.full_settings = loader._settings.values
conanfile.info.scope = self._current_scopes
conanfile.cpp_info = CppInfo(current_path)
conanfile.env_info = EnvInfo(current_path)
registry = RemoteRegistry(self._client_cache.registry, self._user_io.out)
return (builder, deps_graph, project_reference, registry, conanfile,
remote_proxy, loader)
def components_libs_order_test(self):
info = CppInfo("dep1", "")
info.components["liba"].libs = ["liba"]
info.components["libb"].libs = ["libb"]
dep_cpp_info = DepCppInfo(info)
self.assertListEqual(["liba", "libb"], dep_cpp_info.libs)
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("dep1", dep_cpp_info)
self.assertListEqual(["liba", "libb"], deps_cpp_info["dep1"].libs)
self.assertListEqual(["liba", "libb"], list(deps_cpp_info.libs))
info = CppInfo("dep1", "")
info.components["liba"].libs = ["liba"]
info.components["libb"].libs = ["libb"]
dep_cpp_info = DepCppInfo(info)
info2 = CppInfo("dep2", "")
info2.components["libc"].libs = ["libc"]
dep_cpp_info2 = DepCppInfo(info2)
deps_cpp_info = DepsCppInfo()
# Update in reverse order
deps_cpp_info.add("dep2", dep_cpp_info2)
deps_cpp_info.add("dep1", dep_cpp_info)
self.assertListEqual(["liba", "libb"], deps_cpp_info["dep1"].libs)
self.assertListEqual(["libc"], deps_cpp_info["dep2"].libs)
self.assertListEqual(["libc", "liba", "libb"],
list(deps_cpp_info.libs))
info = CppInfo("dep1", "")
info.components["liba"].libs = ["liba"]
info.components["libb"].libs = ["libb"]
info.components["libb"].requires = ["liba"]
dep_cpp_info = DepCppInfo(info)
self.assertListEqual(["libb", "liba"], dep_cpp_info.libs)
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("dep1", dep_cpp_info)
self.assertListEqual(["libb", "liba"], deps_cpp_info["dep1"].libs)
self.assertListEqual(["libb", "liba"], list(deps_cpp_info.libs))
info = CppInfo("dep1", "")
info.components["liba"].libs = ["liba"]
info.components["libb"].libs = ["libb"]
info.components["libb"].requires = ["liba"]
dep_cpp_info = DepCppInfo(info)
info2 = CppInfo("dep2", "")
info2.components["libc"].libs = ["libc"]
dep_cpp_info2 = DepCppInfo(info2)
deps_cpp_info = DepsCppInfo()
# Update in reverse order
deps_cpp_info.add("dep2", dep_cpp_info2)
deps_cpp_info.add("dep1", dep_cpp_info)
self.assertListEqual(["libb", "liba"], deps_cpp_info["dep1"].libs)
self.assertListEqual(["libc"], deps_cpp_info["dep2"].libs)
self.assertListEqual(["libc", "libb", "liba"],
list(deps_cpp_info.libs))
def test_names_per_generator(self):
cpp_info = CppInfo("pkg_name", "root")
cpp_info.name = "name"
cpp_info.names["txt"] = "txt_name"
cpp_info.names["cmake_find_package"] = "SpecialName"
cpp_info.filenames["cmake_find_package"] = "SpecialFileName"
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
conanfile.deps_cpp_info.add("pkg_name", DepCppInfo(cpp_info))
content = TXTGenerator(conanfile).content
parsed_deps_cpp_info, _, _, _ = TXTGenerator.loads(content, filter_empty=False)
parsed_cpp_info = parsed_deps_cpp_info["pkg_name"]
self.assertEqual(parsed_cpp_info.get_name("txt"), "txt_name")
self.assertEqual(parsed_cpp_info.get_name("cmake_find_package"), "SpecialName")
self.assertEqual(parsed_cpp_info.get_filename("cmake_find_package"), "SpecialFileName")
self.assertEqual(parsed_cpp_info.get_name("pkg_config"), "pkg_name")
def deps_cpp_info_components_test(self):
folder = temp_folder()
info = CppInfo("my_lib", folder)
# Create file so path is not cleared
save(os.path.join(folder, "include", "my_file.h"), "")
info.components["Component"].libs = ["libcomp"]
dep_info = DepCppInfo(info)
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("my_lib", dep_info)
self.assertListEqual(["libcomp"], deps_cpp_info.libs)
self.assertListEqual(
["libcomp"], deps_cpp_info["my_lib"].components["Component"].libs)
self.assertListEqual([os.path.join(folder, "include")],
deps_cpp_info.include_paths)
self.assertListEqual(
[os.path.join(folder, "include")],
deps_cpp_info["my_lib"].components["Component"].include_paths)
def write_generators(conanfile, path, output):
""" produces auxiliary files, required to build a project or a package.
"""
from conans.model.build_info import CppInfo
conanfile.cpp_info = CppInfo(path)
conanfile.cpp_info.dependencies = []
conanfile.package_info()
for generator_name in conanfile.generators:
if generator_name not in registered_generators:
output.warn(
"Invalid generator '%s'. Available types: %s" %
(generator_name, ", ".join(registered_generators.available)))
else:
generator_class = registered_generators[generator_name]
try:
generator = generator_class(conanfile)
except TypeError:
# To allow old-style generator packages to work (e.g. premake)
output.warn(
"Generator %s failed with new __init__(), trying old one")
generator = generator_class(conanfile.deps_cpp_info,
conanfile.cpp_info)
try:
content = generator.content
if isinstance(content, dict):
if generator.filename:
output.warn(
"Generator %s is multifile. Property 'filename' not used"
% (generator_name, ))
for k, v in content.items():
v = normalize(v)
output.info("Generated %s created %s" %
(generator_name, k))
save(join(path, k), v)
else:
content = normalize(content)
output.info("Generated %s created %s" %
(generator_name, generator.filename))
save(join(path, generator.filename), content)
except Exception as e:
output.error("Generator %s(file:%s) failed\n%s" %
(generator_name, generator.filename, str(e)))
def cpp_info_test(self):
folder = temp_folder()
info = CppInfo(folder)
info.includedirs.append("/usr/include")
info.libdirs.append("/usr/lib")
bin_abs_dir = "C:/usr/bin" if platform.system(
) == "Windows" else "/tmp"
info.bindirs.append(bin_abs_dir)
info.bindirs.append("local_bindir")
self.assertEqual(info.include_paths,
[os.path.join(folder, "include"), "/usr/include"])
self.assertEqual(info.lib_paths,
[os.path.join(folder, "lib"), "/usr/lib"])
self.assertEqual(info.bin_paths, [
os.path.join(folder, "bin"), bin_abs_dir,
os.path.join(folder, "local_bindir")
])
def test_component_name_same_package():
"""
When the package and the component are the same the variables declared in data and linked
to the target have to be the same.
https://github.com/conan-io/conan/issues/9071"""
conanfile = ConanFile(Mock(), None)
conanfile._conan_node = Mock()
conanfile._conan_node.context = "host"
conanfile.settings = "os", "compiler", "build_type", "arch"
conanfile.initialize(
Settings({
"os": ["Windows"],
"compiler": ["gcc"],
"build_type": ["Release"],
"arch": ["x86"]
}), EnvValues())
conanfile.settings.build_type = "Release"
conanfile.settings.arch = "x86"
cpp_info = CppInfo("mypkg", "dummy_root_folder1")
# We adjust the component with the same name as the package on purpose
cpp_info.components["mypkg"].includedirs = ["includedirs1"]
conanfile_dep = ConanFile(Mock(), None)
conanfile_dep.cpp_info = cpp_info
conanfile_dep._conan_node = Mock()
conanfile_dep._conan_node.context = "host"
conanfile_dep._conan_node.ref = ConanFileReference.loads("mypkg/1.0")
conanfile_dep.folders.set_base_package("/path/to/folder_dep")
with mock.patch('conans.ConanFile.dependencies',
new_callable=mock.PropertyMock) as mock_deps:
req = Requirement(ConanFileReference.loads("mypkg/1.0"))
mock_deps.return_value = ConanFileDependencies(
{req: ConanFileInterface(conanfile_dep)})
cmakedeps = CMakeDeps(conanfile)
files = cmakedeps.content
target_cmake = files["mypkg-Target-release.cmake"]
assert "$<$<CONFIG:Release>:${mypkg_mypkg_mypkg_INCLUDE_DIRS_RELEASE}> APPEND)" \
in target_cmake
data_cmake = files["mypkg-release-x86-data.cmake"]
assert 'set(mypkg_mypkg_mypkg_INCLUDE_DIRS_RELEASE ' \
'"${mypkg_PACKAGE_FOLDER_RELEASE}/includedirs1")' in data_cmake
def escaped_flags_test(self):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.includedirs.append("other_include_dir")
cpp_info.cxxflags = ["-load", r"C:\foo\bar.dll"]
cpp_info.cflags = ["-load", r"C:\foo\bar2.dll"]
cpp_info.defines = ['MY_DEF=My string', 'MY_DEF2=My other string']
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = CMakeGenerator(conanfile)
content = generator.content
cmake_lines = content.splitlines()
self.assertIn(r'set(CONAN_C_FLAGS_MYPKG "-load C:\\foo\\bar2.dll")', cmake_lines)
self.assertIn(r'set(CONAN_CXX_FLAGS_MYPKG "-load C:\\foo\\bar.dll")', cmake_lines)
self.assertIn(r'set(CONAN_DEFINES_MYPKG "-DMY_DEF=My string"', cmake_lines)
self.assertIn('\t\t\t"-DMY_DEF2=My other string")', cmake_lines)
def test_cpp_info_name_cmakedeps(using_properties):
conanfile = ConanFile(Mock(), None)
conanfile.settings = "os", "compiler", "build_type", "arch"
conanfile.initialize(
Settings({
"os": ["Windows"],
"compiler": ["gcc"],
"build_type": ["Release"],
"arch": ["x86"]
}), EnvValues())
conanfile.settings.build_type = "Release"
conanfile.settings.arch = "x86"
cpp_info = CppInfo("mypkg", "dummy_root_folder1")
if using_properties:
cpp_info.set_property("cmake_target_name", "MySuperPkg1")
cpp_info.set_property("cmake_file_name", "ComplexFileName1")
else:
cpp_info.names["cmake_find_package_multi"] = "MySuperPkg1"
cpp_info.filenames["cmake_find_package_multi"] = "ComplexFileName1"
conanfile_dep = ConanFile(Mock(), None)
conanfile_dep.cpp_info = cpp_info
with mock.patch('conans.ConanFile.ref',
new_callable=mock.PropertyMock) as mock_ref:
with mock.patch('conans.ConanFile.dependencies',
new_callable=mock.PropertyMock) as mock_deps:
mock_ref.return_value = ConanFileReference.loads(
"OriginalDepName/1.0")
mock_deps.return_value = Mock()
conanfile_dep.package_folder = "/path/to/folder_dep"
conanfile.dependencies.transitive_host_requires = [
ConanFileInterface(conanfile_dep)
]
conanfile.dependencies.host_requires = [
ConanFileInterface(conanfile_dep)
]
cmakedeps = CMakeDeps(conanfile)
files = cmakedeps.content
assert "TARGET MySuperPkg1::MySuperPkg1" in files[
"ComplexFileName1Config.cmake"]
assert 'set(MySuperPkg1_INCLUDE_DIRS_RELEASE "${MySuperPkg1_PACKAGE_FOLDER}/include")' \
in files["ComplexFileName1-release-x86-data.cmake"]
def init_cpp_info(deps_graph, paths):
""" Made external so it is independent of installer and can called
in testing too
"""
# Assign export root folders
for node in deps_graph.nodes:
conan_ref, conan_file = node
if conan_ref:
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
package_folder = paths.package(package_reference)
conan_file.cpp_info = CppInfo(package_folder)
try:
conan_file.package_info()
except Exception as e:
raise ConanException("Error in %s\n\tpackage_info()\n\t%s" %
(conan_ref, str(e)))
def test_cpp_info_name_cmakedeps_components():
conanfile = ConanFile(Mock(), None)
conanfile._conan_node = Mock()
conanfile._conan_node.context = "host"
conanfile.settings = "os", "compiler", "build_type", "arch"
conanfile.initialize(
Settings({
"os": ["Windows"],
"compiler": ["gcc"],
"build_type": ["Release", "Debug"],
"arch": ["x86", "x64"]
}), EnvValues())
conanfile.settings.build_type = "Debug"
conanfile.settings.arch = "x64"
cpp_info = CppInfo("mypkg", "dummy_root_folder1")
cpp_info.set_property("cmake_target_name",
"GlobakPkgName1::GlobakPkgName1")
cpp_info.components["mycomp"].set_property("cmake_target_name",
"GlobakPkgName1::MySuperPkg1")
cpp_info.set_property("cmake_file_name", "ComplexFileName1")
conanfile_dep = ConanFile(Mock(), None)
conanfile_dep.cpp_info = cpp_info
conanfile_dep._conan_node = Mock()
conanfile_dep._conan_node.ref = ConanFileReference.loads(
"OriginalDepName/1.0")
conanfile_dep._conan_node.context = "host"
conanfile_dep.folders.set_base_package("/path/to/folder_dep")
with mock.patch('conans.ConanFile.dependencies',
new_callable=mock.PropertyMock) as mock_deps:
req = Requirement(ConanFileReference.loads("OriginalDepName/1.0"))
mock_deps.return_value = ConanFileDependencies(
{req: ConanFileInterface(conanfile_dep)})
cmakedeps = CMakeDeps(conanfile)
files = cmakedeps.content
assert "TARGET GlobakPkgName1::MySuperPkg1" in files[
"ComplexFileName1-Target-debug.cmake"]
assert 'set(OriginalDepName_INCLUDE_DIRS_DEBUG ' \
'"${OriginalDepName_PACKAGE_FOLDER_DEBUG}/include")' \
in files["ComplexFileName1-debug-x64-data.cmake"]
assert 'set(OriginalDepName_GlobakPkgName1_MySuperPkg1_INCLUDE_DIRS_DEBUG ' \
'"${OriginalDepName_PACKAGE_FOLDER_DEBUG}/include")' \
in files["ComplexFileName1-debug-x64-data.cmake"]
def paths_cmake_test(self):
settings_mock = _MockSettings()
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(settings_mock, EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
tmp_folder = temp_folder()
save(os.path.join(tmp_folder, "lib", "mylib.lib"), "")
save(os.path.join(tmp_folder, "include", "myheader.h"), "")
cpp_info = CppInfo(ref.name, tmp_folder)
cpp_info.release.libs = ["hello"]
cpp_info.debug.libs = ["hello_D"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = CMakeGenerator(conanfile)
content = generator.content
content = content.replace(tmp_folder.replace("\\", "/"), "root_folder")
cmake_lines = content.splitlines()
self.assertIn('set(CONAN_INCLUDE_DIRS_MYPKG_RELEASE "root_folder/include")', cmake_lines)
self.assertIn('set(CONAN_LIB_DIRS_MYPKG_RELEASE "root_folder/lib")', cmake_lines)
def _loads_cpp_info(text):
pattern = re.compile(r"^\[([a-zA-Z0-9._:-]+)\]([^\[]+)", re.MULTILINE)
result = DepsCppInfo()
try:
for m in pattern.finditer(text):
var_name = m.group(1)
lines = []
for line in m.group(2).splitlines():
line = line.strip()
if not line or line[0] == "#":
continue
lines.append(line)
if not lines:
continue
tokens = var_name.split(":")
if len(tokens) == 2: # has config
var_name, config = tokens
else:
config = None
tokens = var_name.split("_", 1)
field = tokens[0]
if len(tokens) == 2:
dep = tokens[1]
dep_cpp_info = result._dependencies.setdefault(
dep, CppInfo(root_folder=""))
if field in ["rootpath", "sysroot"]:
lines = lines[0]
item_to_apply = dep_cpp_info
else:
if field == "sysroot":
lines = lines[0]
item_to_apply = result
if config:
config_deps = getattr(item_to_apply, config)
setattr(config_deps, field, lines)
else:
setattr(item_to_apply, field, lines)
except Exception as e:
logger.error(traceback.format_exc())
raise ConanException(
"There was an error parsing conanbuildinfo.txt: %s" % str(e))
return result
def paths_cmake_test(self):
settings_mock = namedtuple("Settings", "build_type, os, os_build, constraint, items")
conanfile = ConanFile(None, None)
conanfile.initialize(settings_mock(None, None, None, lambda x, raise_undefined_field: x,
lambda: {}), EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
tmp_folder = temp_folder()
save(os.path.join(tmp_folder, "lib", "mylib.lib"), "")
save(os.path.join(tmp_folder, "include", "myheader.h"), "")
cpp_info = CppInfo(tmp_folder)
cpp_info.release.libs = ["hello"]
cpp_info.debug.libs = ["hello_D"]
conanfile.deps_cpp_info.update(cpp_info, ref.name)
generator = CMakeGenerator(conanfile)
content = generator.content
content = content.replace(tmp_folder.replace("\\", "/"), "root_folder")
cmake_lines = content.splitlines()
self.assertIn('set(CONAN_INCLUDE_DIRS_MYPKG_RELEASE "root_folder/include")', cmake_lines)
self.assertIn('set(CONAN_LIB_DIRS_MYPKG_RELEASE "root_folder/lib")', cmake_lines)
def extend(cpp_info, config):
""" adds the specific config configuration to the common one
"""
config_info = cpp_info.configs.get(config)
if config_info:
result = CppInfo(config_info.rootpath)
result.includedirs = cpp_info.includedirs + config_info.includedirs
result.libdirs = cpp_info.libdirs + config_info.libdirs
result.bindirs = cpp_info.bindirs + config_info.bindirs
result.resdirs = cpp_info.resdirs + config_info.resdirs
result.builddirs = cpp_info.builddirs + config_info.builddirs
result.libs = cpp_info.libs + config_info.libs
result.defines = cpp_info.defines + config_info.defines
result.cflags = cpp_info.cflags + config_info.cflags
result.cppflags = cpp_info.cppflags + config_info.cppflags
result.sharedlinkflags = cpp_info.sharedlinkflags + config_info.sharedlinkflags
result.exelinkflags = cpp_info.exelinkflags + config_info.exelinkflags
return result
return cpp_info
def paths_cmake_multi_user_vars_test(self):
settings_mock = _MockSettings(build_type="Release")
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(settings_mock, EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
tmp_folder = temp_folder()
save(os.path.join(tmp_folder, "lib", "mylib.lib"), "")
save(os.path.join(tmp_folder, "include", "myheader.h"), "")
cpp_info = CppInfo(tmp_folder)
cpp_info.name = ref.name
cpp_info.release.libs = ["hello"]
cpp_info.debug.libs = ["hello_D"]
conanfile.deps_cpp_info.update(cpp_info, ref.name)
generator = CMakeMultiGenerator(conanfile)
release = generator.content["conanbuildinfo_release.cmake"]
release = release.replace(tmp_folder.replace("\\", "/"), "root_folder")
cmake_lines = release.splitlines()
self.assertIn('set(CONAN_INCLUDE_DIRS_MYPKG_RELEASE "root_folder/include")', cmake_lines)
self.assertIn('set(CONAN_LIB_DIRS_MYPKG_RELEASE "root_folder/lib")', cmake_lines)
def test_cmake_deps_links_flags():
# https://github.com/conan-io/conan/issues/8703
conanfile = ConanFile(Mock(), None)
conanfile.settings = "os", "compiler", "build_type", "arch"
conanfile.initialize(
Settings({
"os": ["Windows"],
"compiler": ["gcc"],
"build_type": ["Release"],
"arch": ["x86"]
}), EnvValues())
conanfile.settings.build_type = "Release"
conanfile.settings.arch = "x86"
cpp_info = CppInfo("mypkg", "dummy_root_folder1")
# https://github.com/conan-io/conan/issues/8811 regression, fix with explicit - instead of /
cpp_info.sharedlinkflags = ["-NODEFAULTLIB", "-OTHERFLAG"]
cpp_info.exelinkflags = ["-OPT:NOICF"]
conanfile_dep = ConanFile(Mock(), None)
conanfile_dep.cpp_info = cpp_info
with mock.patch('conans.ConanFile.ref',
new_callable=mock.PropertyMock) as mock_ref:
with mock.patch('conans.ConanFile.dependencies',
new_callable=mock.PropertyMock) as mock_deps:
mock_ref.return_value = ConanFileReference.loads("mypkg/1.0")
mock_deps.return_value = Mock()
conanfile.dependencies.transitive_host_requires = []
conanfile.dependencies.host_requires = []
conanfile_dep.package_folder = "/path/to/folder_dep"
conanfile.dependencies.transitive_host_requires = [
ConanFileInterface(conanfile_dep)
]
conanfile.dependencies.host_requires = [
ConanFileInterface(conanfile_dep)
]
cmakedeps = CMakeDeps(conanfile)
files = cmakedeps.content
data_cmake = files["mypkg-release-x86-data.cmake"]
assert "set(mypkg_SHARED_LINK_FLAGS_RELEASE -NODEFAULTLIB;-OTHERFLAG)" in data_cmake
assert "set(mypkg_EXE_LINK_FLAGS_RELEASE -OPT:NOICF)" in data_cmake
def call_package_info(conanfile, package_folder):
conanfile.cpp_info = CppInfo(package_folder)
conanfile.cpp_info.version = conanfile.version
conanfile.cpp_info.description = conanfile.description
conanfile.env_info = EnvInfo()
conanfile.user_info = UserInfo()
# Get deps_cpp_info from upstream nodes
public_deps = [name for name, req in conanfile.requires.items() if not req.private]
conanfile.cpp_info.public_deps = public_deps
# Once the node is build, execute package info, so it has access to the
# package folder and artifacts
with tools.chdir(package_folder):
with conanfile_exception_formatter(str(conanfile), "package_info"):
conanfile.package_folder = package_folder
conanfile.source_folder = None
conanfile.build_folder = None
conanfile.install_folder = None
conanfile.package_info()
def test_types(self):
deps_cpp_info = DepsCppInfo()
cpp_info = CppInfo("pkg", "rootpath")
cpp_info.version = "version"
cpp_info.libs = ["lib1", "lib2"]
cpp_info.includedirs = ["include1"]
deps_cpp_info.add("pkg", DepCppInfo(cpp_info))
info_for_package = deps_cpp_info["pkg"]
# Documented as list for 'self.cpp_info' object
self.assertIsInstance(info_for_package.includedirs, list)
self.assertIsInstance(info_for_package.libdirs, list)
self.assertIsInstance(info_for_package.resdirs, list)
self.assertIsInstance(info_for_package.bindirs, list)
self.assertIsInstance(info_for_package.builddirs, list)
self.assertIsInstance(info_for_package.libs, list)
self.assertIsInstance(info_for_package.defines, list)
self.assertIsInstance(info_for_package.cflags, list)
self.assertIsInstance(info_for_package.cppflags, list)
self.assertIsInstance(info_for_package.cxxflags, list)
self.assertIsInstance(info_for_package.sharedlinkflags, list)
self.assertIsInstance(info_for_package.exelinkflags, list)
self.assertIsInstance(info_for_package.frameworks, list)
self.assertIsInstance(info_for_package.frameworkdirs, list)
self.assertIsInstance(info_for_package.rootpath, six.string_types)
self.assertIsInstance(info_for_package.name, six.string_types)
self.assertIsInstance(info_for_package.system_libs, list)
self.assertIsInstance(info_for_package.build_modules, list)
self.assertIsInstance(info_for_package.components, dict)
# Documented as list for `deps_cpp_info["pkg"]`
self.assertIsInstance(info_for_package.include_paths, list)
self.assertIsInstance(info_for_package.lib_paths, list)
self.assertIsInstance(info_for_package.bin_paths, list)
self.assertIsInstance(info_for_package.build_paths, list)
self.assertIsInstance(info_for_package.res_paths, list)
self.assertIsInstance(info_for_package.framework_paths, list)
self.assertIsInstance(info_for_package.build_modules_paths, list)
self.assertIsInstance(info_for_package.get_name("generator"),
six.string_types)
self.assertIsInstance(info_for_package.version, six.string_types)
self.assertIsInstance(info_for_package.components, dict)
def _call_package_info(self, conanfile, package_folder, ref):
conanfile.cpp_info = CppInfo(package_folder)
conanfile.cpp_info.name = conanfile.name
conanfile.cpp_info.version = conanfile.version
conanfile.cpp_info.description = conanfile.description
conanfile.env_info = EnvInfo()
conanfile.user_info = UserInfo()
# Get deps_cpp_info from upstream nodes
public_deps = [
name for name, req in conanfile.requires.items()
if not req.private and not req.override
]
conanfile.cpp_info.public_deps = public_deps
# Once the node is build, execute package info, so it has access to the
# package folder and artifacts
conan_v2 = get_env(CONAN_V2_MODE_ENVVAR, False)
with pythonpath(conanfile) if not conan_v2 else no_op(
): # Minimal pythonpath, not the whole context, make it 50% slower
with tools.chdir(package_folder):
with conanfile_exception_formatter(str(conanfile),
"package_info"):
conanfile.package_folder = package_folder
conanfile.source_folder = None
conanfile.build_folder = None
conanfile.install_folder = None
self._hook_manager.execute("pre_package_info",
conanfile=conanfile,
reference=ref)
conanfile.package_info()
if conanfile._conan_dep_cpp_info is None:
try:
conanfile.cpp_info._raise_incorrect_components_definition(
conanfile.name, conanfile.requires)
except ConanException as e:
raise ConanException("%s package_info(): %s" %
(str(conanfile), e))
conanfile._conan_dep_cpp_info = DepCppInfo(
conanfile.cpp_info)
self._hook_manager.execute("post_package_info",
conanfile=conanfile,
reference=ref)
def init_info_objects(deps_graph, paths):
""" Made external so it is independent of installer and can called
in testing too
"""
# Assign export root folders
for node in deps_graph.nodes:
conan_ref, conan_file = node
if conan_ref:
package_id = conan_file.info.package_id()
package_reference = PackageReference(conan_ref, package_id)
package_folder = paths.package(package_reference)
conan_file.package_folder = package_folder
conan_file.cpp_info = CppInfo(package_folder)
conan_file.env_info = EnvInfo(package_folder)
try:
conan_file.package_info()
except Exception as e:
msg = format_conanfile_exception(str(conan_ref),
"package_info", e)
raise ConanException(msg)
def cmake_vars_unit_test(self):
settings = _MockSettings("Release")
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(settings, EnvValues())
tmp = temp_folder()
cpp_info = CppInfo("MyLib", tmp)
custom_dir = os.path.join(tmp, "custom_build_dir")
os.mkdir(custom_dir)
cpp_info.builddirs.append(os.path.join(tmp, "custom_build_dir"))
conanfile.deps_cpp_info.add("MyLib", cpp_info)
generator = CMakePathsGenerator(conanfile)
path = tmp.replace('\\', '/')
custom_dir = custom_dir.replace('\\', '/')
cmake_lines = generator.content.replace('\\', '/').replace("\n\t\t\t", " ").splitlines()
self.assertEqual('set(CONAN_MYLIB_ROOT "%s")' % path, cmake_lines[0])
self.assertEqual('set(CMAKE_MODULE_PATH "%s/" "%s" ${CMAKE_MODULE_PATH} '
'${CMAKE_CURRENT_LIST_DIR})' % (path, custom_dir), cmake_lines[1])
self.assertEqual('set(CMAKE_PREFIX_PATH "%s/" "%s" ${CMAKE_PREFIX_PATH} '
'${CMAKE_CURRENT_LIST_DIR})' % (path, custom_dir), cmake_lines[2])
def cpp_info_test(self):
folder = temp_folder()
mkdir(os.path.join(folder, "include"))
mkdir(os.path.join(folder, "lib"))
mkdir(os.path.join(folder, "local_bindir"))
abs_folder = temp_folder()
abs_include = os.path.join(abs_folder, "usr/include")
abs_lib = os.path.join(abs_folder, "usr/lib")
abs_bin = os.path.join(abs_folder, "usr/bin")
mkdir(abs_include)
mkdir(abs_lib)
mkdir(abs_bin)
info = CppInfo("", folder)
info.includedirs.append(abs_include)
info.libdirs.append(abs_lib)
info.bindirs.append(abs_bin)
info.bindirs.append("local_bindir")
self.assertListEqual(list(info.include_paths), [os.path.join(folder, "include"), abs_include])
self.assertListEqual(list(info.lib_paths), [os.path.join(folder, "lib"), abs_lib])
self.assertListEqual(list(info.bin_paths), [abs_bin, os.path.join(folder, "local_bindir")])
def cppinfo_public_interface_test(self):
folder = temp_folder()
info = CppInfo("", folder)
self.assertEqual([], info.libs)
self.assertEqual([], info.system_libs)
self.assertEqual(["include"], info.includedirs)
self.assertEqual([], info.srcdirs)
self.assertEqual(["res"], info.resdirs)
self.assertEqual([""], info.builddirs)
self.assertEqual(["bin"], info.bindirs)
self.assertEqual(["lib"], info.libdirs)
self.assertEqual(folder, info.rootpath)
self.assertEqual([], info.defines)
self.assertEqual("", info.sysroot)
self.assertEqual([], info.cflags)
self.assertEqual({}, info.configs)
self.assertEqual([], info.cxxflags)
self.assertEqual([], info.exelinkflags)
self.assertEqual([], info.public_deps)
self.assertEqual([], info.sharedlinkflags)
def _get_conanfile(self, settings):
conan_file = ConanFileMock()
conan_file.settings = settings
conan_file.source_folder = "my_cache_source_folder"
conan_file.build_folder = "my_cache_build_folder"
conan_file.deps_env_info = DepsEnvInfo()
conan_file.deps_user_info = DepsUserInfo()
conan_file.deps_cpp_info = DepsCppInfo()
cpp_info = CppInfo("/root")
cpp_info.include_paths.append("path/to/include1")
cpp_info.lib_paths.append("path/to/lib1")
cpp_info.libs.append("mylib")
cpp_info.bindirs = "path/to/bin1"
cpp_info.cflags.append("c_flag1")
cpp_info.cppflags.append("cxx_flag1")
cpp_info.defines.append("mydefine1")
conan_file.deps_cpp_info.update(cpp_info, "zlib")
conan_file.env_info = EnvInfo()
return conan_file
def test_bazeldeps_dependency_buildfiles():
conanfile = ConanFile(Mock(), None)
cpp_info = CppInfo("mypkg", "dummy_root_folder1")
conanfile_dep = ConanFile(Mock(), None)
conanfile_dep.cpp_info = cpp_info
conanfile_dep._conan_node = Mock()
conanfile_dep._conan_node.ref = ConanFileReference.loads("OriginalDepName/1.0")
conanfile_dep.package_folder = "/path/to/folder_dep"
with mock.patch('conans.ConanFile.dependencies', new_callable=mock.PropertyMock) as mock_deps:
req = Requirement(ConanFileReference.loads("OriginalDepName/1.0"))
mock_deps.return_value = ConanFileDependencies({req: ConanFileInterface(conanfile_dep)})
bazeldeps = BazelDeps(conanfile)
for dependency in bazeldeps._conanfile.dependencies.host.values():
dependency_content = bazeldeps._get_dependency_buildfile_content(dependency)
assert 'cc_library(\n name = "OriginalDepName",' in dependency_content
