def test_deps_cpp_info_paths(self):
deps_cpp_info = DepsCppInfo()
folder1 = temp_folder()
dep1 = CppInfo(folder1)
os.mkdir(os.path.join(folder1, "include"))
os.mkdir(os.path.join(folder1, "includea"))
os.mkdir(os.path.join(folder1, "includeb"))
dep1.components["liba"].includedirs.append("includea")
dep1.components["libb"].includedirs.append("includeb")
deps_cpp_info.update(DepCppInfo(dep1), "dep1")
folder2 = temp_folder()
dep2 = CppInfo(folder2)
os.mkdir(os.path.join(folder2, "include"))
os.mkdir(os.path.join(folder2, "includec"))
os.mkdir(os.path.join(folder2, "included"))
dep2.components["libc"].includedirs.append("includec")
dep2.components["libd"].includedirs.append("included")
deps_cpp_info.update(DepCppInfo(dep2), "dep2")
self.assertListEqual([os.path.join(folder1, "include"), os.path.join(folder1, "includea"),
os.path.join(folder1, "includeb")],
deps_cpp_info["dep1"].include_paths)
self.assertListEqual([os.path.join(folder2, "include"), os.path.join(folder2, "includec"),
os.path.join(folder2, "included")],
deps_cpp_info["dep2"].include_paths)
self.assertListEqual([os.path.join(folder1, "include"), os.path.join(folder1, "includea"),
os.path.join(folder1, "includeb"), os.path.join(folder2, "include"),
os.path.join(folder2, "includec"), os.path.join(folder2, "included")],
deps_cpp_info.include_paths)
def test_deps_cpp_info_libs_release_debug(self):
deps_cpp_info = DepsCppInfo()
dep1 = CppInfo("dep1", "root")
dep1.components["liba"].libs.append("liba")
with self.assertRaises(AttributeError):
dep1.release.components["libb"].libs.append("libb")
with self.assertRaises(AttributeError):
dep1.debug.components["libb"].libs.append("libb_d")
deps_cpp_info.add("dep1", DepCppInfo(dep1))
dep2 = CppInfo("dep2", "root")
dep2.release.libs.append("libdep2")
dep2.debug.libs.append("libdep2_d")
with self.assertRaises(AttributeError):
dep2.components["libc"].release.libs.append("libc")
with self.assertRaises(AttributeError):
dep2.components["libc"].debug.libs.append("libc_d")
dep2.components["libc"].libs.append("libc")
dep2.components["libc"].libs.append("libc2")
deps_cpp_info.add("dep2", DepCppInfo(dep2))
self.assertListEqual(["liba"], deps_cpp_info["dep1"].libs)
self.assertListEqual(["libc", "libc2"], deps_cpp_info["dep2"].libs)
self.assertListEqual(["liba", "libc", "libc2"], deps_cpp_info.libs)
self.assertListEqual([], deps_cpp_info["dep1"].release.libs)
self.assertListEqual(["libdep2"], deps_cpp_info["dep2"].release.libs)
self.assertListEqual(["libdep2"], deps_cpp_info.release.libs)
self.assertListEqual([], deps_cpp_info["dep1"].debug.libs)
self.assertListEqual(["libdep2_d"], deps_cpp_info["dep2"].debug.libs)
self.assertListEqual(["libdep2_d"], deps_cpp_info.debug.libs)
def cppinfo_inexistent_component_dep_test(self):
info = CppInfo(None)
info.components["LIB1"].requires = ["LIB2"]
with six.assertRaisesRegex(self, ConanException, "Component 'LIB1' "
"declares a missing dependency"):
DepCppInfo(info).libs
info.components["LIB1"].requires = ["::LIB2"]
with six.assertRaisesRegex(self, ConanException, "Leading character '::' not allowed in "
"LIB1 requires"):
DepCppInfo(info).libs
def cpp_info_system_libs_test(self):
info1 = CppInfo("dep1", "folder1")
info1.system_libs = ["sysdep1"]
info2 = CppInfo("dep2", "folder2")
info2.system_libs = ["sysdep2", "sysdep3"]
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("dep1", DepCppInfo(info1))
deps_cpp_info.add("dep2", DepCppInfo(info2))
self.assertListEqual(["sysdep1", "sysdep2", "sysdep3"], list(deps_cpp_info.system_libs))
self.assertListEqual(["sysdep1"], list(deps_cpp_info["dep1"].system_libs))
self.assertListEqual(["sysdep2", "sysdep3"], list(deps_cpp_info["dep2"].system_libs))
def cppinfo_inexistent_component_dep_test(self):
info = CppInfo("", None)
info.components["LIB1"].requires = ["LIB2"]
with six.assertRaisesRegex(
self, ConanException, "Component 'LIB1' required components "
"not found in this package: 'LIB2'"):
_ = DepCppInfo(info).libs
info.components["LIB1"].requires = ["::LIB2"]
with six.assertRaisesRegex(
self, ConanException, "Leading character '::' not allowed in "
"LIB1 requires"):
_ = DepCppInfo(info).libs
def _call_package_info(self, conanfile, package_folder, ref):
conanfile.cpp_info = CppInfo(conanfile.name, 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
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 help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
child = CppInfo("Boost", "F:")
child.filter_empty = False
child.includedirs.append("ChildrenPath")
child.cxxflags.append("cxxmyflag")
deps_cpp_info.add("Boost", DepCppInfo(child))
fakeconan = namedtuple(
"Conanfile",
"deps_cpp_info cpp_info deps_env_info env_info user_info deps_user_info"
)
output = TXTGenerator(
fakeconan(deps_cpp_info, None, deps_env_info, None, {},
defaultdict(dict))).content
deps_cpp_info2, _, _, _ = TXTGenerator.loads(output)
self.assertEqual(deps_cpp_info.configs, deps_cpp_info2.configs)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cxxflags,
deps_cpp_info2["Boost"].cxxflags)
self.assertEqual(deps_cpp_info["Boost"].cxxflags, ["cxxmyflag"])
def system_frameworks_libs_test(self):
# https://github.com/conan-io/conan/issues/7301
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
cpp_info = CppInfo("MyPkg", "/rootpath")
cpp_info.version = "0.1"
cpp_info.libs = ["mypkg"]
cpp_info.system_libs = ["pthread"]
cpp_info.frameworks = ["cocoa"]
cpp_info.frameworkdirs = ["frameworks"]
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add("MyPkg", DepCppInfo(cpp_info))
generator = SConsGenerator(conanfile)
content = generator.content
scons_lines = content.splitlines()
self.assertIn(' "LIBS" : [\'mypkg\', \'pthread\'],',
scons_lines)
self.assertIn(' "FRAMEWORKS" : [\'cocoa\'],', scons_lines)
if platform.system() == "Windows":
self.assertIn(
' "FRAMEWORKPATH" : [\'/rootpath\\\\frameworks\'],',
scons_lines)
else:
self.assertIn(
' "FRAMEWORKPATH" : [\'/rootpath/frameworks\'],',
scons_lines)
self.assertIn(' "MyPkg_version" : "0.1",', scons_lines)
def test_cpp_info_name_cmakedeps_components():
conanfile = ConanFile(Mock(), None)
conanfile.settings = "os", "compiler", "build_type", "arch"
conanfile.initialize(
Settings({
"os": ["Windows"],
"compiler": ["gcc"],
"build_type": ["Release"],
"arch": ["x86"]
}), EnvValues())
cpp_info = CppInfo("mypkg", "dummy_root_folder1")
cpp_info.names["cmake_find_package_multi"] = "GlobakPkgName1"
cpp_info.components["mycomp"].names[
"cmake_find_package_multi"] = "MySuperPkg1"
cpp_info.filenames["cmake_find_package_multi"] = "ComplexFileName1"
conanfile.deps_cpp_info.add("mypkg", DepCppInfo(cpp_info))
cmakedeps = CMakeDeps(conanfile)
files = cmakedeps.content
assert "TARGET GlobakPkgName1::MySuperPkg1" in files[
"ComplexFileName1Config.cmake"]
with pytest.raises(
ConanException,
match="'mypkg' defines information for 'cmake_find_package_multi'"
):
with environment_append({CONAN_V2_MODE_ENVVAR: "1"}):
_ = cmakedeps.content
def _content(self):
# We cannot use self._conanfile.warn(), because that fails for virtual conanfile
print("*** The 'msbuild' generator is EXPERIMENTAL ***")
if not self._conanfile.settings.get_safe("build_type"):
raise ConanException("The 'msbuild' generator requires a 'build_type' setting value")
result = {}
general_name = "conandeps.props"
conf_name = self._config_filename()
condition = self._condition()
# Include all direct build_requires for host context. This might change
direct_deps = self._conanfile.dependencies.host_requires
result[general_name] = self._all_props_file(general_name, direct_deps)
for dep in self._conanfile.dependencies.transitive_host_requires:
dep_name = dep.ref.name
cpp_info = DepCppInfo(dep.cpp_info) # To account for automatic component aggregation
public_deps = [d.ref.name for d in dep.dependencies.requires]
# One file per configuration, with just the variables
vars_props_name = "conan_%s_vars%s.props" % (dep_name, conf_name)
result[vars_props_name] = self._vars_props_file(dep_name, cpp_info, public_deps)
props_name = "conan_%s%s.props" % (dep_name, conf_name)
result[props_name] = self._conf_props_file(dep_name, vars_props_name, public_deps)
# The entry point for each package, it will have conditionals to the others
file_dep_name = "conan_%s.props" % dep_name
dep_content = self._dep_props_file(dep_name, file_dep_name, props_name, condition)
result[file_dep_name] = dep_content
return result
def test_cpp_info_build_modules(self):
folder = temp_folder()
info = CppInfo("myname", folder)
info.build_modules.append(
"old.cmake") # Test old behavior with .cmake build modules
info.build_modules.extend(["other_old.cmake",
"file.pc"]) # .pc not considered
info.build_modules["generator"].append("my_module.cmake")
info.debug.build_modules["other_gen"] = ["mod-release.cmake"]
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("myname", DepCppInfo(info))
for gen in [
"cmake", "cmake_multi", "cmake_find_package",
"cmake_find_package_multi"
]:
self.assertListEqual([
os.path.join(folder, "old.cmake"),
os.path.join(folder, "other_old.cmake")
], list(deps_cpp_info["myname"].build_modules_paths[gen]))
self.assertListEqual(
[os.path.join(folder, "my_module.cmake")],
list(deps_cpp_info["myname"].build_modules_paths["generator"]))
self.assertListEqual([
os.path.join(folder, "mod-release.cmake")
], list(
deps_cpp_info["myname"].debug.build_modules_paths["other_gen"]))
def cpp_info_components_requires_loop_test(self):
info = CppInfo("", "")
info.components["LIB1"].requires = ["LIB1"]
msg = "There is a dependency loop in 'self.cpp_info.components' requires"
with six.assertRaisesRegex(self, ConanException, msg):
DepCppInfo(info).libs
info = CppInfo("", "")
info.components["LIB1"].requires = ["LIB2"]
info.components["LIB2"].requires = ["LIB1", "LIB2"]
with six.assertRaisesRegex(self, ConanException, msg):
DepCppInfo(info).build_paths
info = CppInfo("", "")
info.components["LIB1"].requires = ["LIB2"]
info.components["LIB2"].requires = ["LIB3"]
info.components["LIB3"].requires = ["LIB1"]
with six.assertRaisesRegex(self, ConanException, msg):
DepCppInfo(info).defines
def cpp_info_name_test(self):
folder = temp_folder()
info = CppInfo("myname", folder)
info.name = "MyName"
info.names["my_generator"] = "MyNameForMyGenerator"
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("myname", DepCppInfo(info))
self.assertIn("MyName", deps_cpp_info["myname"].get_name("my_undefined_generator"))
self.assertIn("MyNameForMyGenerator", deps_cpp_info["myname"].get_name("my_generator"))
def configs_test(self):
deps_cpp_info = DepsCppInfo()
deps_cpp_info.filter_empty = False
child = CppInfo("Boost", "F:/")
child.filter_empty = False
child.version = "<version>"
child.includedirs.append("ChildrenPath")
child.debug.includedirs.append("ChildrenDebugPath")
child.cxxflags.append("cxxmyflag")
child.debug.cxxflags.append("cxxmydebugflag")
child.libs.extend(["math"])
child.debug.libs.extend(["debug_Lib"])
deps_cpp_info.add("Boost", DepCppInfo(child))
deps_env_info = DepsEnvInfo()
env_info_lib1 = EnvInfo()
env_info_lib1.var = "32"
env_info_lib1.othervar.append("somevalue")
deps_env_info.update(env_info_lib1, "LIB1")
deps_user_info = DepsUserInfo()
deps_user_info["LIB2"].myuservar = "23"
fakeconan = namedtuple("Conanfile", "deps_cpp_info cpp_info deps_env_info env_info user_info deps_user_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, deps_env_info, deps_user_info, {}, defaultdict(dict))).content
deps_cpp_info2, _, deps_env_info2, _ = TXTGenerator.loads(output, filter_empty=False)
self.assertEqual(deps_cpp_info.includedirs, deps_cpp_info2.includedirs)
self.assertEqual(deps_cpp_info.libdirs, deps_cpp_info2.libdirs)
self.assertEqual(deps_cpp_info.bindirs, deps_cpp_info2.bindirs)
self.assertEqual(deps_cpp_info.libs, deps_cpp_info2.libs)
self.assertEqual(len(deps_cpp_info._dependencies),
len(deps_cpp_info2._dependencies))
self.assertEqual(deps_cpp_info["Boost"].includedirs,
deps_cpp_info2["Boost"].includedirs)
self.assertEqual(deps_cpp_info["Boost"].cxxflags,
deps_cpp_info2["Boost"].cxxflags)
self.assertEqual(deps_cpp_info["Boost"].cxxflags, ["cxxmyflag"])
self.assertEqual(deps_cpp_info.debug.includedirs, deps_cpp_info2.debug.includedirs)
self.assertEqual(deps_cpp_info.debug.includedirs, ['F:/include', 'F:/ChildrenDebugPath'])
self.assertEqual(deps_cpp_info.debug.libs, deps_cpp_info2.debug.libs)
self.assertEqual(deps_cpp_info.debug.libs, ["debug_Lib"])
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs,
deps_cpp_info2["Boost"].debug.includedirs)
self.assertEqual(deps_cpp_info["Boost"].debug.includedirs, ['include', 'ChildrenDebugPath'])
self.assertEqual(deps_cpp_info["Boost"].debug.cxxflags,
deps_cpp_info2["Boost"].debug.cxxflags)
self.assertEqual(deps_cpp_info["Boost"].debug.cxxflags, ["cxxmydebugflag"])
self.assertEqual(deps_env_info["LIB1"].var, "32")
self.assertEqual(deps_env_info["LIB1"].othervar, ["somevalue"])
self.assertEqual(deps_user_info["LIB2"].myuservar, "23")
def cpp_info_build_modules_test(self):
folder = temp_folder()
info = CppInfo("myname", folder)
info.build_modules.append("my_module.cmake")
info.debug.build_modules = ["mod-release.cmake"]
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("myname", DepCppInfo(info))
self.assertListEqual([os.path.join(folder, "my_module.cmake")],
list(deps_cpp_info["myname"].build_modules_paths))
self.assertListEqual([os.path.join(folder, "mod-release.cmake")],
list(deps_cpp_info["myname"].debug.build_modules_paths))
def test_exelinkflags(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.exelinkflags = ["-llibrary_for_exe"]
conanfile.deps_cpp_info.add("MyPkg", DepCppInfo(cpp_info))
generator = QmakeGenerator(conanfile)
content = generator.content
qmake_lines = content.splitlines()
self.assertIn('CONAN_QMAKE_LFLAGS_APP += -llibrary_for_exe', qmake_lines)
def test_deps_cpp_info_libs(self):
deps_cpp_info = DepsCppInfo()
dep1 = CppInfo("dep1", "root")
dep1.components["liba"].libs.append("liba")
dep1.components["libb"].libs.append("libb")
deps_cpp_info.add("dep1", DepCppInfo(dep1))
dep2 = CppInfo("dep2", "root")
dep2.components["libc"].libs.append("libc")
dep2.components["libd"].libs.append("libd")
deps_cpp_info.add("dep2", DepCppInfo(dep2))
dep3 = CppInfo("dep3", "root")
dep3.libs.append("libdep3")
deps_cpp_info.add("dep3", DepCppInfo(dep3))
self.assertListEqual(["liba", "libb"], deps_cpp_info["dep1"].libs)
self.assertListEqual(["libc", "libd"], deps_cpp_info["dep2"].libs)
self.assertListEqual(["libdep3"], deps_cpp_info["dep3"].libs)
self.assertListEqual(["liba", "libb", "libc", "libd", "libdep3"],
deps_cpp_info.libs)
def test_system_libs(self):
# https://github.com/conan-io/conan/issues/7558
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
cpp_info = CppInfo("MyPkg", "/rootpath")
cpp_info.libs = ["mypkg"]
cpp_info.system_libs = ["pthread"]
conanfile.deps_cpp_info.add("MyPkg", DepCppInfo(cpp_info))
generator = QmakeGenerator(conanfile)
content = generator.content
qmake_lines = content.splitlines()
self.assertIn('CONAN_LIBS += -lmypkg', qmake_lines)
self.assertIn('CONAN_SYSTEMLIBS += -lpthread', qmake_lines)
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_deps_cpp_info_components_includedirs(self):
info = CppInfo("my_lib", "root")
info.components["component"].includedirs = ["include1", "include2"]
info.components["component"].filter_empty = False
dep_info = DepCppInfo(info)
expected = [
os.path.join("root", "include1"),
os.path.join("root", "include2")
]
self.assertListEqual(expected, list(dep_info.include_paths))
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("my_lib", dep_info)
self.assertListEqual(expected, list(deps_cpp_info.includedirs))
def test_cpp_info_build_modules_old_behavior(self):
folder = temp_folder()
info = CppInfo("myname", folder)
info.build_modules = [
"old.cmake"
] # Test old behavior with .cmake build modules as list
deps_cpp_info = DepsCppInfo()
deps_cpp_info.add("myname", DepCppInfo(info))
for gen in [
"cmake", "cmake_multi", "cmake_find_package",
"cmake_find_package_multi"
]:
assert list(deps_cpp_info["myname"].build_modules_paths[gen]) ==\
[os.path.join(folder, "old.cmake")]
def deps_cpp_info_components_test(self):
folder = temp_folder()
info = CppInfo(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.update(dep_info, "my_lib")
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 component_default_dirs_deps_cpp_info_test(self):
folder = temp_folder()
info = CppInfo(folder)
info.components["Component"]
info.components["Component"].filter_empty = False # For testing purposes
dep_info = DepCppInfo(info)
deps_cpp_info = DepsCppInfo()
deps_cpp_info.update(dep_info, "my_lib")
self.assertListEqual([os.path.join(folder, "include")], deps_cpp_info.includedirs)
self.assertListEqual([], deps_cpp_info.srcdirs)
self.assertListEqual([os.path.join(folder, "lib")], deps_cpp_info.libdirs)
self.assertListEqual([os.path.join(folder, "bin")], deps_cpp_info.bindirs)
self.assertListEqual([os.path.join(folder, "")], deps_cpp_info.builddirs)
self.assertListEqual([os.path.join(folder, "res")], deps_cpp_info.resdirs)
self.assertListEqual([os.path.join(folder, "Frameworks")], deps_cpp_info.frameworkdirs)
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 merge(dep):
dep_cpp_info = DepCppInfo(dep.cpp_info) # To deal with components
self.system_libs = merge_lists(self.system_libs, dep_cpp_info.system_libs)
self.include_paths = merge_lists(self.include_paths, dep_cpp_info.include_paths)
self.lib_paths = merge_lists(self.lib_paths, dep_cpp_info.lib_paths)
self.framework_paths = merge_lists(self.framework_paths, dep_cpp_info.framework_paths)
self.libs = merge_lists(self.libs, dep_cpp_info.libs)
self.frameworks = merge_lists(self.frameworks, dep_cpp_info.frameworks)
# Note these are in reverse order
self.defines = merge_lists(dep_cpp_info.defines, self.defines)
self.cxxflags = merge_lists(dep_cpp_info.cxxflags, self.cxxflags)
self.cflags = merge_lists(dep_cpp_info.cflags, self.cflags)
self.sharedlinkflags = merge_lists(dep_cpp_info.sharedlinkflags, self.sharedlinkflags)
self.exelinkflags = merge_lists(dep_cpp_info.exelinkflags, self.exelinkflags)
if not self.sysroot:
self.sysroot = dep_cpp_info.sysroot
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(conanfile.name, 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 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
# Minimal pythonpath, not the whole context, make it 50% slower
# FIXME Conan 2.0, Remove old ways of reusing python code
with pythonpath(conanfile):
with tools.chdir(package_folder):
with conanfile_exception_formatter(str(conanfile),
"package_info"):
conanfile.layout.set_base_package_folder(package_folder)
conanfile.layout.set_base_source_folder(None)
conanfile.layout.set_base_build_folder(None)
conanfile.layout.set_base_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 variables_setup_test(self):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "")
cpp_info.defines = ["MYDEFINE1"]
cpp_info.version = "0.1"
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/3.2.3@lasote/stables")
cpp_info = CppInfo(ref.name, "")
cpp_info.defines = ["MYDEFINE2"]
cpp_info.version = "3.2.3"
conanfile.deps_cpp_info.add(ref.name, DepCppInfo(cpp_info))
generator = SConsGenerator(conanfile)
content = generator.content
scons_lines = content.splitlines()
self.assertIn(" \"CPPDEFINES\" : ['MYDEFINE2', 'MYDEFINE1'],",
scons_lines)
self.assertIn(" \"CPPDEFINES\" : ['MYDEFINE1'],", scons_lines)
self.assertIn(" \"CPPDEFINES\" : ['MYDEFINE2'],", scons_lines)
self.assertIn(' "conan_version" : "None",', scons_lines)
self.assertIn(' "MyPkg_version" : "0.1",', scons_lines)
self.assertIn(' "MyPkg2_version" : "3.2.3",', scons_lines)
def test_deps_cpp_info_libs_defines_flags(self):
deps_cpp_info = DepsCppInfo()
dep1 = CppInfo("dep1", "root")
dep1.components["liba"].libs.append("liba")
dep1.components["liba"].defines.append("DEFINEA")
dep1.components["liba"].system_libs.append("sysa")
dep1.components["liba"].cxxflags.append("cxxflaga")
dep1.components["liba"].cflags.append("cflaga")
dep1.components["liba"].sharedlinkflags.append("slinka")
dep1.components["liba"].frameworks.append("frameworka")
dep1.components["liba"].exelinkflags.append("elinka")
dep1.components["libb"].libs.append("libb")
dep1.components["libb"].defines.append("DEFINEB")
dep1.components["libb"].system_libs.append("sysb")
dep1.components["libb"].cxxflags.append("cxxflagb")
dep1.components["libb"].cflags.append("cflagb")
dep1.components["libb"].sharedlinkflags.append("slinkb")
dep1.components["libb"].frameworks.append("frameworkb")
dep1.components["libb"].exelinkflags.append("elinkb")
deps_cpp_info.add("dep1", DepCppInfo(dep1))
dep2 = CppInfo("dep2", "root")
dep2.components["libc"].libs.append("libc")
dep2.components["libd"].libs.append("libd")
dep2.components["systemlib"].system_libs = ["systemlib"]
dep2.components["libc"].cxxflags = ["cxxflagc"]
dep2.components["libd"].cflags = ["cflagd"]
dep2.components["libc"].sharedlinkflags = ["slinkc"]
dep2.components["libd"].sharedlinkflags = ["slinkd"]
deps_cpp_info.add("dep2", DepCppInfo(dep2))
self.assertListEqual(["liba", "libb"], deps_cpp_info["dep1"].libs)
self.assertListEqual(["libc", "libd"], deps_cpp_info["dep2"].libs)
self.assertListEqual(["liba", "libb", "libc", "libd"],
deps_cpp_info.libs)
self.assertListEqual(["DEFINEA", "DEFINEB"],
deps_cpp_info["dep1"].defines)
self.assertListEqual(["DEFINEA", "DEFINEB"], deps_cpp_info.defines)
self.assertListEqual(["sysa", "sysb"],
deps_cpp_info["dep1"].system_libs)
self.assertListEqual(["systemlib"], deps_cpp_info["dep2"].system_libs)
self.assertListEqual(["sysa", "sysb", "systemlib"],
deps_cpp_info.system_libs)
self.assertListEqual(["cxxflaga", "cxxflagb"],
deps_cpp_info["dep1"].cxxflags)
self.assertListEqual(["cxxflagc"], deps_cpp_info["dep2"].cxxflags)
self.assertListEqual(["cxxflagc", "cxxflaga", "cxxflagb"],
deps_cpp_info.cxxflags)
self.assertListEqual(["cflaga", "cflagb"],
deps_cpp_info["dep1"].cflags)
self.assertListEqual(["cflagd"], deps_cpp_info["dep2"].cflags)
self.assertListEqual(["cflagd", "cflaga", "cflagb"],
deps_cpp_info.cflags)
self.assertListEqual(["slinka", "slinkb"],
deps_cpp_info["dep1"].sharedlinkflags)
self.assertListEqual(["slinkc", "slinkd"],
deps_cpp_info["dep2"].sharedlinkflags)
self.assertListEqual(["slinkc", "slinkd", "slinka", "slinkb"],
deps_cpp_info.sharedlinkflags)
self.assertListEqual(["frameworka", "frameworkb"],
deps_cpp_info["dep1"].frameworks)
self.assertListEqual(["frameworka", "frameworkb"],
deps_cpp_info.frameworks)
self.assertListEqual(["elinka", "elinkb"],
deps_cpp_info["dep1"].exelinkflags)
self.assertListEqual([], deps_cpp_info["dep2"].exelinkflags)
self.assertListEqual(["elinka", "elinkb"], deps_cpp_info.exelinkflags)
