def help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.includedirs.append("C:/whenever")
deps_cpp_info.libdirs.append("C:/other")
deps_cpp_info.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
deps_cpp_info._dependencies["Boost"] = 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"].cppflags,
deps_cpp_info2["Boost"].cppflags)
self.assertEqual(deps_cpp_info["Boost"].cppflags, ["cxxmyflag"])
def configs_test(self):
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.debug.includedirs.append("C:/whenever")
deps_cpp_info.libs.extend(["math"])
deps_cpp_info.debug.libs.extend(["debug_Lib"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.debug.includedirs.append("F:/ChildrenDebugPath")
child.cppflags.append("cxxmyflag")
child.debug.cppflags.append("cxxmydebugflag")
deps_cpp_info._dependencies["Boost"] = 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)
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"].cppflags,
deps_cpp_info2["Boost"].cppflags)
self.assertEqual(deps_cpp_info["Boost"].cppflags, ["cxxmyflag"])
self.assertEqual(deps_cpp_info.debug.includedirs, deps_cpp_info2.debug.includedirs)
self.assertEqual(deps_cpp_info.debug.includedirs, ["C:/whenever"])
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,
["F:/ChildrenDebugPath"])
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags,
deps_cpp_info2["Boost"].debug.cppflags)
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags, ["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 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 help_test(self):
imports = DepsCppInfo()
imports.includedirs.append("C:/whatever")
imports.includedirs.append("C:/whenever")
imports.libdirs.append("C:/other")
imports.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
imports._dependencies["Boost"] = child
output = repr(imports)
imports2 = DepsCppInfo.loads(output)
self._equal(imports, imports2)
def initialize(self, settings, env):
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings)
if 'cppstd' in self.settings.fields:
conan_v2_behavior("Setting 'cppstd' is deprecated in favor of 'compiler.cppstd',"
" please update your recipe.", v1_behavior=self.output.warn)
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self._conan_dep_cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names (only 'host' if different contexts)
self.deps_user_info = DepsUserInfo()
# user specified env variables
self._conan_env_values = env.copy() # user specified -e
if self.description is not None and not isinstance(self.description, six.string_types):
raise ConanException("Recipe 'description' must be a string.")
def config_patch_test(self):
conan_file = ConanFileMock()
conan_file.name = "MyPkg"
conan_file.settings = Settings()
conan_file.source_folder = os.path.join(self.tempdir, "src")
conan_file.build_folder = os.path.join(self.tempdir, "build")
conan_file.package_folder = os.path.join(self.tempdir, "pkg")
conan_file.deps_cpp_info = DepsCppInfo()
msg = "FOLDER: " + conan_file.package_folder
for folder in (conan_file.build_folder, conan_file.package_folder):
save(os.path.join(folder, "file1.cmake"), "Nothing")
save(os.path.join(folder, "file2"), msg)
save(os.path.join(folder, "file3.txt"), msg)
save(os.path.join(folder, "file3.cmake"), msg)
save(os.path.join(folder, "sub", "file3.cmake"), msg)
cmake = CMake(conan_file, generator="Unix Makefiles")
cmake.patch_config_paths()
for folder in (conan_file.build_folder, conan_file.package_folder):
self.assertEqual("Nothing", load(os.path.join(folder, "file1.cmake")))
self.assertEqual(msg, load(os.path.join(folder, "file2")))
self.assertEqual(msg, load(os.path.join(folder, "file3.txt")))
self.assertEqual("FOLDER: ${CONAN_MYPKG_ROOT}",
load(os.path.join(folder, "file3.cmake")))
self.assertEqual("FOLDER: ${CONAN_MYPKG_ROOT}",
load(os.path.join(folder, "sub", "file3.cmake")))
def _get_conanfile(settings, frameworks=False, system_libs=False):
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.cxxflags.append("cxx_flag1")
cpp_info.defines.append("mydefine1")
if system_libs:
cpp_info.system_libs.append("system_lib1")
if frameworks:
cpp_info.frameworks = ["AVFoundation", "VideoToolbox"]
cpp_info.framework_paths.extend(['path/to/Frameworks1', 'path/to/Frameworks2'])
conan_file.deps_cpp_info.update(cpp_info, "zlib")
conan_file.env_info = EnvInfo()
return conan_file
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 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 __init__(self, output, runner, settings, conanfile_directory):
'''
param settings: Settings
'''
# User defined generators
self.generators = self.generators if hasattr(self, "generators") else ["txt"]
self.generators = [self.generators] if isinstance(self.generators, str) \
else self.generators
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings)
self.exports = create_exports(self)
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
self.copy = None # initialized at runtime
# an output stream (writeln, info, warn error)
self.output = output
# something that can run commands, as os.sytem
self._runner = runner
self._conanfile_directory = conanfile_directory
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 initialize(self, settings, env, local=None):
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings, local)
try:
if self.settings.os_build and self.settings.os:
self.output.writeln("*"*60, front=Color.BRIGHT_RED)
self.output.writeln(" This package defines both 'os' and 'os_build' ",
front=Color.BRIGHT_RED)
self.output.writeln(" Please use 'os' for libraries and 'os_build'",
front=Color.BRIGHT_RED)
self.output.writeln(" only for build-requires used for cross-building",
front=Color.BRIGHT_RED)
self.output.writeln("*"*60, front=Color.BRIGHT_RED)
except ConanException:
pass
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names, and the values a dict with the vars
self.deps_user_info = DepsUserInfo()
# user specified env variables
self._conan_env_values = env.copy() # user specified -e
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 initialize(self, settings, env):
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings)
if 'cppstd' in self.settings.fields:
self.output.warn(
"Setting 'cppstd' is deprecated in favor of 'compiler.cppstd',"
" please update your recipe.")
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names, and the values a dict with the vars
self.deps_user_info = DepsUserInfo()
# user specified env variables
self._conan_env_values = env.copy() # user specified -e
def cpp_info_name_test(self):
folder = temp_folder()
info = CppInfo(folder)
info.name = "MyName"
deps_cpp_info = DepsCppInfo()
deps_cpp_info.update(info, "myname")
self.assertIn("MyName", deps_cpp_info["myname"].name)
def initialize(self, settings, env, buildenv=None):
self._conan_buildenv = buildenv
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings)
conan_v2_error("Setting 'cppstd' is deprecated in favor of 'compiler.cppstd',"
" please update your recipe.", 'cppstd' in self.settings.fields)
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self._conan_dep_cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names (only 'host' if different contexts)
self.deps_user_info = DepsUserInfo()
# user specified env variables
self._conan_env_values = env.copy() # user specified -e
if self.description is not None and not isinstance(self.description, six.string_types):
raise ConanException("Recipe 'description' must be a string.")
if not hasattr(self, "virtualenv"): # Allow the user to override it with True or False
self.virtualenv = True
def configs_test(self):
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.debug.includedirs.append("C:/whenever")
deps_cpp_info.libs.extend(["math"])
deps_cpp_info.debug.libs.extend(["debug_Lib"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.debug.includedirs.append("F:/ChildrenDebugPath")
child.cppflags.append("cxxmyflag")
child.debug.cppflags.append("cxxmydebugflag")
deps_cpp_info._dependencies["Boost"] = child
fakeconan = namedtuple(
"Conanfile", "deps_cpp_info cpp_info deps_env_info env_info")
output = TXTGenerator(fakeconan(deps_cpp_info, None, None,
None)).content
deps_cpp_info2 = DepsCppInfo.loads(output)
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"].cppflags,
deps_cpp_info2["Boost"].cppflags)
self.assertEqual(deps_cpp_info["Boost"].cppflags, ["cxxmyflag"])
self.assertEqual(deps_cpp_info.debug.includedirs,
deps_cpp_info2.debug.includedirs)
self.assertEqual(deps_cpp_info.debug.includedirs, ["C:/whenever"])
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,
["F:/ChildrenDebugPath"])
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags,
deps_cpp_info2["Boost"].debug.cppflags)
self.assertEqual(deps_cpp_info["Boost"].debug.cppflags,
["cxxmydebugflag"])
def help_test(self):
deps_env_info = DepsEnvInfo()
deps_cpp_info = DepsCppInfo()
deps_cpp_info.includedirs.append("C:/whatever")
deps_cpp_info.includedirs.append("C:/whenever")
deps_cpp_info.libdirs.append("C:/other")
deps_cpp_info.libs.extend(["math", "winsock", "boost"])
child = DepsCppInfo()
child.includedirs.append("F:/ChildrenPath")
child.cppflags.append("cxxmyflag")
deps_cpp_info._dependencies["Boost"] = child
fakeconan = namedtuple(
"Conanfile", "deps_cpp_info cpp_info deps_env_info env_info")
output = TXTGenerator(
fakeconan(deps_cpp_info, None, deps_env_info, None)).content
deps_cpp_info2 = DepsCppInfo.loads(output)
self._equal(deps_cpp_info, deps_cpp_info2)
def __init__(self, output, runner, settings, user=None, channel=None, local=None):
# User defined generators
self.generators = self.generators if hasattr(self, "generators") else ["txt"]
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings, local)
try:
if self.settings.os_build and self.settings.os:
output.writeln("*"*60, front=Color.BRIGHT_RED)
output.writeln(" This package defines both 'os' and 'os_build' ",
front=Color.BRIGHT_RED)
output.writeln(" Please use 'os' for libraries and 'os_build'",
front=Color.BRIGHT_RED)
output.writeln(" only for build-requires used for cross-building",
front=Color.BRIGHT_RED)
output.writeln("*"*60, front=Color.BRIGHT_RED)
except ConanException:
pass
self.exports = create_exports(self)
self.exports_sources = create_exports_sources(self)
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names, and the values a dict with the vars
self.deps_user_info = DepsUserInfo()
self.copy = None # initialized at runtime
self.copy_deps = None # initialized at runtime
# an output stream (writeln, info, warn error)
self.output = output
# something that can run commands, as os.sytem
self._runner = runner
self.develop = False
# user specified env variables
self._env_values = EnvValues() # Updated at runtime, user specified -e
self._user = user
self._channel = channel
self.in_local_cache = False
self.description = None
# Vars to control the build steps (build(), package())
self.should_configure = True
self.should_build = True
self.should_install = True
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 _loads_cpp_info(text):
pattern = re.compile(r"^\[([a-zA-Z0-9._:-]+)\]([^\[]+)", re.MULTILINE)
try:
# Parse the text
data = defaultdict(lambda: defaultdict(dict))
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
if 'system_libs' in var_name:
tokens = var_name.split("system_libs_", 1)
field = 'system_libs'
else:
tokens = var_name.split("_", 1)
field = tokens[0]
dep = tokens[1] if len(tokens) == 2 else None
if field == "cppflags":
field = "cxxflags"
data[dep][config][field] = lines
# Build the data structures
deps_cpp_info = DepsCppInfo()
for dep, configs_cpp_info in data.items():
if dep is None:
cpp_info = deps_cpp_info
else:
cpp_info = deps_cpp_info._dependencies.setdefault(
dep, CppInfo(root_folder=""))
for config, fields in configs_cpp_info.items():
item_to_apply = cpp_info if not config else getattr(
cpp_info, config)
for key, value in fields.items():
if key in ['rootpath', 'sysroot']:
value = value[0]
setattr(item_to_apply, key, value)
return deps_cpp_info
except Exception as e:
logger.error(traceback.format_exc())
raise ConanException(
"There was an error parsing conanbuildinfo.txt: %s" % str(e))
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 variables_setup_test(self):
conanfile = ConanFile(None, None, Settings({}), None)
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = DepsCppInfo()
cpp_info.defines = ["MYDEFINE1"]
conanfile.deps_cpp_info.update(cpp_info, ref)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = DepsCppInfo()
cpp_info.defines = ["MYDEFINE2"]
conanfile.deps_cpp_info.update(cpp_info, ref)
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)
def cpp_info_system_libs_test(self):
info1 = CppInfo("folder1")
info1.system_libs = ["sysdep1"]
info2 = CppInfo("folder2")
info2.system_libs = ["sysdep2", "sysdep3"]
deps_cpp_info = DepsCppInfo()
deps_cpp_info.update(info1, "dep1")
deps_cpp_info.update(info2, "dep2")
self.assertEqual(["sysdep1", "sysdep2", "sysdep3"], deps_cpp_info.system_libs)
self.assertEqual(["sysdep1"], deps_cpp_info["dep1"].system_libs)
self.assertEqual(["sysdep2", "sysdep3"], deps_cpp_info["dep2"].system_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 __init__(self,
output,
runner,
settings,
conanfile_directory,
user=None,
channel=None):
# User defined generators
self.generators = self.generators if hasattr(
self, "generators") else ["txt"]
if isinstance(self.generators, str):
self.generators = [self.generators]
# User defined options
self.options = create_options(self)
self.requires = create_requirements(self)
self.settings = create_settings(self, settings)
self.exports = create_exports(self)
self.exports_sources = create_exports_sources(self)
# needed variables to pack the project
self.cpp_info = None # Will be initialized at processing time
self.deps_cpp_info = DepsCppInfo()
# environment variables declared in the package_info
self.env_info = None # Will be initialized at processing time
self.deps_env_info = DepsEnvInfo()
# user declared variables
self.user_info = None
# Keys are the package names, and the values a dict with the vars
self.deps_user_info = DepsUserInfo()
self.copy = None # initialized at runtime
# an output stream (writeln, info, warn error)
self.output = output
# something that can run commands, as os.sytem
self._runner = runner
self.conanfile_directory = conanfile_directory
self._scope = None
self.develop = False
# user specified env variables
self._env_values = EnvValues() # Updated at runtime, user specified -e
self._user = user
self._channel = channel
# Are we in local cache? Suggest a better name
self.in_local_cache = False
# Init a description
self.description = None
def cpp_info_build_modules_test(self):
folder = temp_folder()
info = CppInfo(folder)
info.build_modules.append("my_module.cmake")
info.debug.build_modules = ["mod-release.cmake"]
deps_cpp_info = DepsCppInfo()
deps_cpp_info.update(info, "myname")
self.assertListEqual([os.path.join(folder, "my_module.cmake")],
deps_cpp_info["myname"].build_modules_paths)
self.assertListEqual([os.path.join(folder, "mod-release.cmake")],
deps_cpp_info["myname"].debug.build_modules_paths)
def test_cpp_info_build_modules(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_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")]
