def variables_setup_test(self):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
# Add some cpp_info for dependencies
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.defines = ["MYDEFINE1"]
cpp_info.cflags.append("-Flag1=23")
cpp_info.version = "1.3"
cpp_info.description = "My cool description"
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.defines = ["MYDEFINE2"]
cpp_info.version = "2.3"
cpp_info.exelinkflags = ["-exelinkflag"]
cpp_info.sharedlinkflags = ["-sharedlinkflag"]
cpp_info.cxxflags = ["-cxxflag"]
cpp_info.public_deps = ["MyPkg"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
# Add env_info
env_info = EnvInfo()
env_info.VAR1 = "env_info-value1"
env_info.PATH.append("path-extended")
conanfile.deps_env_info.update(env_info, "env_info_pkg")
# Add user_info
user_info = UserInfo()
user_info.VAR1 = "user_info-value1"
conanfile.deps_user_info["user_info_pkg"] = user_info
# Add user_info_build
conanfile.user_info_build = DepsUserInfo()
user_info = UserInfo()
user_info.VAR1 = "user_info_build-value1"
conanfile.user_info_build["user_info_build_pkg"] = user_info
generator = JsonGenerator(conanfile)
json_out = generator.content
parsed = json.loads(json_out)
# Check dependencies
dependencies = parsed["dependencies"]
self.assertEqual(len(dependencies), 2)
my_pkg = dependencies[0]
self.assertEqual(my_pkg["name"], "MyPkg")
self.assertEqual(my_pkg["description"], "My cool description")
self.assertEqual(my_pkg["defines"], ["MYDEFINE1"])
# Check env_info
env_info = parsed["deps_env_info"]
self.assertListEqual(sorted(env_info.keys()), sorted(["VAR1", "PATH"]))
self.assertEqual(env_info["VAR1"], "env_info-value1")
self.assertListEqual(env_info["PATH"], ["path-extended"])
# Check user_info
user_info = parsed["deps_user_info"]
self.assertListEqual(list(user_info.keys()), ["user_info_pkg"])
self.assertListEqual(list(user_info["user_info_pkg"].keys()), ["VAR1"])
self.assertEqual(user_info["user_info_pkg"]["VAR1"],
"user_info-value1")
# Check user_info_build
user_info_build = parsed["user_info_build"]
self.assertListEqual(list(user_info_build.keys()),
["user_info_build_pkg"])
self.assertListEqual(
list(user_info_build["user_info_build_pkg"].keys()), ["VAR1"])
self.assertEqual(user_info_build["user_info_build_pkg"]["VAR1"],
"user_info_build-value1")
def test_make_generator():
tmp_folder1 = temp_folder()
tmp_folder2 = temp_folder()
save(os.path.join(tmp_folder1, "include1", "file.h"), "")
save(os.path.join(tmp_folder2, "include2", "file.h"), "")
save(os.path.join(tmp_folder1, "lib1", "file.a"), "")
save(os.path.join(tmp_folder2, "lib2", "file.a"), "")
save(os.path.join(tmp_folder1, "bin1", "file.bin"), "")
save(os.path.join(tmp_folder2, "bin2", "file.bin"), "")
save(os.path.join(tmp_folder1, "SystemFrameworks", "file.bin"), "")
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg1/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, tmp_folder1)
cpp_info.defines = ["MYDEFINE1"]
cpp_info.includedirs = ['include1']
cpp_info.libdirs = ['lib1']
cpp_info.libs = ['libfoo']
cpp_info.bindirs = ['bin1']
cpp_info.version = "0.1"
cpp_info.cflags = ['-fgimple']
cpp_info.cxxflags = ['-fdollars-in-identifiers']
cpp_info.sharedlinkflags = ['-framework Cocoa']
cpp_info.exelinkflags = ['-framework QuartzCore']
cpp_info.frameworks = ['AudioUnit']
cpp_info.frameworkdirs = ['SystemFrameworks']
cpp_info.system_libs = ["system_lib1"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/3.2.3@lasote/stables")
cpp_info = CppInfo(ref.name, tmp_folder2)
cpp_info.defines = ["MYDEFINE2"]
cpp_info.includedirs = ['include2']
cpp_info.libdirs = ['lib2']
cpp_info.libs = ['libbar']
cpp_info.bindirs = ['bin2']
cpp_info.version = "3.2.3"
cpp_info.cflags = ['-fno-asm']
cpp_info.cxxflags = ['-pthread']
cpp_info.sharedlinkflags = ['-framework AudioFoundation']
cpp_info.exelinkflags = ['-framework VideoToolbox']
cpp_info.system_libs = ["system_lib2"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = MakeGenerator(conanfile)
content = generator.content
content_template = """
CONAN_ROOT_MYPKG1 ?= \\
{conan_root_mypkg1}
CONAN_SYSROOT_MYPKG1 ?= \\
CONAN_INCLUDE_DIRS_MYPKG1 += \\
{conan_include_dirs_mypkg1}
CONAN_LIB_DIRS_MYPKG1 += \\
{conan_lib_dirs_mypkg1}
CONAN_BIN_DIRS_MYPKG1 += \\
{conan_bin_dirs_mypkg1}
CONAN_BUILD_DIRS_MYPKG1 += \\
{conan_build_dirs_mypkg1}/
CONAN_RES_DIRS_MYPKG1 +=
CONAN_LIBS_MYPKG1 += \\
libfoo
CONAN_SYSTEM_LIBS_MYPKG1 += \\
system_lib1
CONAN_DEFINES_MYPKG1 += \\
MYDEFINE1
CONAN_CFLAGS_MYPKG1 += \\
-fgimple
CONAN_CXXFLAGS_MYPKG1 += \\
-fdollars-in-identifiers
CONAN_SHAREDLINKFLAGS_MYPKG1 += \\
-framework Cocoa
CONAN_EXELINKFLAGS_MYPKG1 += \\
-framework QuartzCore
CONAN_FRAMEWORKS_MYPKG1 += \\
AudioUnit
CONAN_FRAMEWORK_PATHS_MYPKG1 += \\
{conan_framework_dirs_mypkg1}/SystemFrameworks
CONAN_ROOT_MYPKG2 ?= \\
{conan_root_mypkg2}
CONAN_SYSROOT_MYPKG2 ?= \\
CONAN_INCLUDE_DIRS_MYPKG2 += \\
{conan_include_dirs_mypkg2}
CONAN_LIB_DIRS_MYPKG2 += \\
{conan_lib_dirs_mypkg2}
CONAN_BIN_DIRS_MYPKG2 += \\
{conan_bin_dirs_mypkg2}
CONAN_BUILD_DIRS_MYPKG2 += \\
{conan_build_dirs_mypkg2}/
CONAN_RES_DIRS_MYPKG2 +=
CONAN_LIBS_MYPKG2 += \\
libbar
CONAN_SYSTEM_LIBS_MYPKG2 += \\
system_lib2
CONAN_DEFINES_MYPKG2 += \\
MYDEFINE2
CONAN_CFLAGS_MYPKG2 += \\
-fno-asm
CONAN_CXXFLAGS_MYPKG2 += \\
-pthread
CONAN_SHAREDLINKFLAGS_MYPKG2 += \\
-framework AudioFoundation
CONAN_EXELINKFLAGS_MYPKG2 += \\
-framework VideoToolbox
CONAN_FRAMEWORKS_MYPKG2 +=
CONAN_FRAMEWORK_PATHS_MYPKG2 +=
CONAN_ROOT += \\
$(CONAN_ROOT_MYPKG1) \\
$(CONAN_ROOT_MYPKG2)
CONAN_SYSROOT += \\
$(CONAN_SYSROOT_MYPKG1) \\
$(CONAN_SYSROOT_MYPKG2)
CONAN_INCLUDE_DIRS += \\
$(CONAN_INCLUDE_DIRS_MYPKG1) \\
$(CONAN_INCLUDE_DIRS_MYPKG2)
CONAN_LIB_DIRS += \\
$(CONAN_LIB_DIRS_MYPKG1) \\
$(CONAN_LIB_DIRS_MYPKG2)
CONAN_BIN_DIRS += \\
$(CONAN_BIN_DIRS_MYPKG1) \\
$(CONAN_BIN_DIRS_MYPKG2)
CONAN_BUILD_DIRS += \\
$(CONAN_BUILD_DIRS_MYPKG1) \\
$(CONAN_BUILD_DIRS_MYPKG2)
CONAN_RES_DIRS += \\
$(CONAN_RES_DIRS_MYPKG1) \\
$(CONAN_RES_DIRS_MYPKG2)
CONAN_LIBS += \\
$(CONAN_LIBS_MYPKG1) \\
$(CONAN_LIBS_MYPKG2)
CONAN_DEFINES += \\
$(CONAN_DEFINES_MYPKG1) \\
$(CONAN_DEFINES_MYPKG2)
CONAN_CFLAGS += \\
$(CONAN_CFLAGS_MYPKG1) \\
$(CONAN_CFLAGS_MYPKG2)
CONAN_CXXFLAGS += \\
$(CONAN_CXXFLAGS_MYPKG1) \\
$(CONAN_CXXFLAGS_MYPKG2)
CONAN_SHAREDLINKFLAGS += \\
$(CONAN_SHAREDLINKFLAGS_MYPKG1) \\
$(CONAN_SHAREDLINKFLAGS_MYPKG2)
CONAN_EXELINKFLAGS += \\
$(CONAN_EXELINKFLAGS_MYPKG1) \\
$(CONAN_EXELINKFLAGS_MYPKG2)
CONAN_FRAMEWORKS += \\
$(CONAN_FRAMEWORKS_MYPKG1) \\
$(CONAN_FRAMEWORKS_MYPKG2)
CONAN_FRAMEWORK_PATHS += \\
$(CONAN_FRAMEWORK_PATHS_MYPKG1) \\
$(CONAN_FRAMEWORK_PATHS_MYPKG2)
"""
root1 = tmp_folder1.replace('\\', '/')
root2 = tmp_folder2.replace('\\', '/')
inc1 = os.path.join(tmp_folder1, 'include1').replace('\\', '/')
inc2 = os.path.join(tmp_folder2, 'include2').replace('\\', '/')
lib1 = os.path.join(tmp_folder1, 'lib1').replace('\\', '/')
lib2 = os.path.join(tmp_folder2, 'lib2').replace('\\', '/')
bin1 = os.path.join(tmp_folder1, 'bin1').replace('\\', '/')
bin2 = os.path.join(tmp_folder2, 'bin2').replace('\\', '/')
expected_content = content_template.format(
conan_root_mypkg1=root1,
conan_include_dirs_mypkg1=inc1,
conan_lib_dirs_mypkg1=lib1,
conan_bin_dirs_mypkg1=bin1,
conan_build_dirs_mypkg1=root1,
conan_root_mypkg2=root2,
conan_include_dirs_mypkg2=inc2,
conan_lib_dirs_mypkg2=lib2,
conan_bin_dirs_mypkg2=bin2,
conan_build_dirs_mypkg2=root2,
conan_framework_dirs_mypkg1=root1)
content = "\n".join(line.strip()
for line in content.splitlines()) # Trailing spaces
assert expected_content in content
def pkg_config_custom_names_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.name = "my_pkg"
cpp_info.names["pkg_config"] = "my_pkg_custom_name"
cpp_info.defines = ["MYDEFINE1"]
cpp_info.cflags.append("-Flag1=23")
cpp_info.version = "1.3"
cpp_info.description = "My cool description"
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg1/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.name = "MYPKG1"
cpp_info.names["pkg_config"] = "my_pkg1_custom_name"
cpp_info.defines = ["MYDEFINE11"]
cpp_info.cflags.append("-Flag1=21")
cpp_info.version = "1.7"
cpp_info.description = "My other cool description"
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.names["pkg_config"] = "my_pkg2_custom_name"
cpp_info.defines = ["MYDEFINE2"]
cpp_info.version = "2.3"
cpp_info.exelinkflags = ["-exelinkflag"]
cpp_info.sharedlinkflags = ["-sharedlinkflag"]
cpp_info.cxxflags = ["-cxxflag"]
cpp_info.public_deps = ["MyPkg", "MyPkg1"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("zlib/1.2.11@lasote/stable")
cpp_info = CppInfo(ref.name, "dummy_root_folder_zlib")
cpp_info.name = "ZLIB"
cpp_info.defines = ["MYZLIBDEFINE2"]
cpp_info.version = "1.2.11"
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("bzip2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.name = "BZip2"
cpp_info.names["pkg_config"] = "BZip2"
cpp_info.defines = ["MYDEFINE2"]
cpp_info.version = "2.3"
cpp_info.exelinkflags = ["-exelinkflag"]
cpp_info.sharedlinkflags = ["-sharedlinkflag"]
cpp_info.cxxflags = ["-cxxflag"]
cpp_info.public_deps = ["MyPkg", "MyPkg1", "zlib"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = PkgConfigGenerator(conanfile)
files = generator.content
self.assertEqual(
files["my_pkg2_custom_name.pc"], """prefix=dummy_root_folder2
libdir=${prefix}/lib
includedir=${prefix}/include
Name: my_pkg2_custom_name
Description: Conan package: my_pkg2_custom_name
Version: 2.3
Libs: -L${libdir} -sharedlinkflag -exelinkflag
Cflags: -I${includedir} -cxxflag -DMYDEFINE2
Requires: my_pkg_custom_name my_pkg1_custom_name
""")
self.assertEqual(
files["my_pkg1_custom_name.pc"], """prefix=dummy_root_folder1
libdir=${prefix}/lib
includedir=${prefix}/include
Name: my_pkg1_custom_name
Description: My other cool description
Version: 1.7
Libs: -L${libdir}
Cflags: -I${includedir} -Flag1=21 -DMYDEFINE11
""")
self.assertEqual(
files["my_pkg_custom_name.pc"], """prefix=dummy_root_folder1
libdir=${prefix}/lib
includedir=${prefix}/include
Name: my_pkg_custom_name
Description: My cool description
Version: 1.3
Libs: -L${libdir}
Cflags: -I${includedir} -Flag1=23 -DMYDEFINE1
""")
self.assertEqual(
files["BZip2.pc"], """prefix=dummy_root_folder2
libdir=${prefix}/lib
includedir=${prefix}/include
Name: BZip2
Description: Conan package: BZip2
Version: 2.3
Libs: -L${libdir} -sharedlinkflag -exelinkflag
Cflags: -I${includedir} -cxxflag -DMYDEFINE2
Requires: my_pkg_custom_name my_pkg1_custom_name zlib
""")
class CMakeBuildModulesTest(unittest.TestCase):
def setUp(self):
settings_mock = _MockSettings(build_type="Release")
self.conanfile = ConanFile(TestBufferConanOutput(), None)
self.conanfile.initialize(settings_mock, EnvValues())
ref = ConanFileReference.loads("my_pkg/0.1@lasote/stables")
cpp_info = CppInfo("dummy_root_folder1")
cpp_info.filter_empty = False # For testing purposes only
cpp_info.name = ref.name
cpp_info.build_modules = ["my-module.cmake"]
self.conanfile.deps_cpp_info.update(cpp_info, ref.name)
ref = ConanFileReference.loads("my_pkg2/0.1@lasote/stables")
cpp_info = CppInfo("dummy_root_folder2")
cpp_info.filter_empty = False # For testing purposes only
cpp_info.name = ref.name
cpp_info.build_modules = ["other-mod.cmake", "not-a-cmake-module.pc"]
cpp_info.release.build_modules = ["release-mod.cmake"]
cpp_info.release.filter_empty = False # For testing purposes only
self.conanfile.deps_cpp_info.update(cpp_info, ref.name)
def cmake_test(self):
generator = CMakeGenerator(self.conanfile)
content = generator.content
self.assertNotIn("not-a-cmake-module.pc", content)
self.assertIn('set(CONAN_BUILD_MODULES_PATHS "dummy_root_folder1/my-module.cmake"'
'\n\t\t\t"dummy_root_folder2/other-mod.cmake" ${CONAN_BUILD_MODULES_PATHS})',
content)
self.assertIn('set(CONAN_BUILD_MODULES_PATHS_MY_PKG "dummy_root_folder1/my-module.cmake")',
content)
self.assertIn('set(CONAN_BUILD_MODULES_PATHS_MY_PKG2 "dummy_root_folder2/other-mod.cmake")',
content)
self.assertIn("macro(conan_include_build_modules)", content)
self.assertIn("conan_include_build_modules()", content)
def cmake_multi_test(self):
generator = CMakeMultiGenerator(self.conanfile)
content = generator.content
self.assertNotIn("not-a-cmake-module.pc", content["conanbuildinfo_release.cmake"])
self.assertIn('set(CONAN_BUILD_MODULES_PATHS_RELEASE '
'"dummy_root_folder1/my-module.cmake"\n\t\t\t'
'"dummy_root_folder2/other-mod.cmake"\n\t\t\t'
'"dummy_root_folder2/release-mod.cmake" '
'${CONAN_BUILD_MODULES_PATHS_RELEASE})',
content["conanbuildinfo_release.cmake"])
self.assertIn('set(CONAN_BUILD_MODULES_PATHS_MY_PKG_RELEASE '
'"dummy_root_folder1/my-module.cmake")',
content["conanbuildinfo_release.cmake"])
self.assertIn('set(CONAN_BUILD_MODULES_PATHS_MY_PKG2_RELEASE '
'"dummy_root_folder2/other-mod.cmake"\n\t\t\t'
'"dummy_root_folder2/release-mod.cmake")',
content["conanbuildinfo_release.cmake"])
self.assertIn("macro(conan_include_build_modules)", content["conanbuildinfo_multi.cmake"])
self.assertIn("conan_include_build_modules()", content["conanbuildinfo_multi.cmake"])
def cmake_find_package_test(self):
generator = CMakeFindPackageGenerator(self.conanfile)
content = generator.content
self.assertIn("Findmy_pkg.cmake", content.keys())
self.assertIn("Findmy_pkg2.cmake", content.keys())
self.assertNotIn("not-a-cmake-module.pc", content["Findmy_pkg2.cmake"])
self.assertIn('set(CMAKE_MODULE_PATH "dummy_root_folder1/" ${CMAKE_MODULE_PATH})',
content["Findmy_pkg.cmake"])
self.assertIn('set(CMAKE_PREFIX_PATH "dummy_root_folder1/" ${CMAKE_PREFIX_PATH})',
content["Findmy_pkg.cmake"])
self.assertIn('set(CMAKE_MODULE_PATH "dummy_root_folder2/" ${CMAKE_MODULE_PATH})',
content["Findmy_pkg2.cmake"])
self.assertIn('set(CMAKE_PREFIX_PATH "dummy_root_folder2/" ${CMAKE_PREFIX_PATH})',
content["Findmy_pkg2.cmake"])
self.assertIn('set(my_pkg_BUILD_MODULES_PATHS "dummy_root_folder1/my-module.cmake")',
content["Findmy_pkg.cmake"])
self.assertIn('set(my_pkg2_BUILD_MODULES_PATHS "dummy_root_folder2/other-mod.cmake")',
content["Findmy_pkg2.cmake"])
def cmake_find_package_multi_test(self):
generator = CMakeFindPackageMultiGenerator(self.conanfile)
content = generator.content
self.assertNotIn("not-a-cmake-module.pc", content["my_pkg2Target-release.cmake"])
self.assertIn('set(my_pkg_BUILD_MODULES_PATHS_RELEASE "dummy_root_folder1/my-module.cmake")',
content["my_pkgTarget-release.cmake"])
self.assertIn('set(my_pkg2_BUILD_MODULES_PATHS_RELEASE "dummy_root_folder2/other-mod.cmake")',
content["my_pkg2Target-release.cmake"])
def test_variables_setup(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.filter_empty = False
cpp_info.name = "my_pkg"
cpp_info.defines = ["MYDEFINE1"]
cpp_info.cflags.append("-Flag1=23")
cpp_info.version = "1.3"
cpp_info.description = "My cool description"
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg1/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "/dummy_root_folder1")
cpp_info.filter_empty = False
cpp_info.name = "MYPKG1"
cpp_info.defines = ["MYDEFINE11"]
cpp_info.cflags.append("-Flag1=21")
cpp_info.version = "1.7"
cpp_info.description = "My other cool description"
cpp_info.public_deps = ["MyPkg"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "/dummy_root_folder2")
cpp_info.filter_empty = False
cpp_info.defines = ["MYDEFINE2"]
cpp_info.version = "2.3"
cpp_info.exelinkflags = ["-exelinkflag"]
cpp_info.sharedlinkflags = ["-sharedlinkflag"]
cpp_info.cxxflags = ["-cxxflag"]
cpp_info.public_deps = ["MyPkg"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = PkgConfigGenerator(conanfile)
files = generator.content
self.assertEqual(
files["MyPkg2.pc"], """prefix=/dummy_root_folder2
libdir=${prefix}/lib
includedir=${prefix}/include
Name: MyPkg2
Description: Conan package: MyPkg2
Version: 2.3
Libs: -L"${libdir}" -sharedlinkflag -exelinkflag
Cflags: -I"${includedir}" -cxxflag -DMYDEFINE2
Requires: my_pkg
""")
self.assertEqual(
files["mypkg1.pc"], """prefix=/dummy_root_folder1
libdir=${prefix}/lib
includedir=${prefix}/include
Name: mypkg1
Description: My other cool description
Version: 1.7
Libs: -L"${libdir}"
Cflags: -I"${includedir}" -Flag1=21 -DMYDEFINE11
Requires: my_pkg
""")
self.assertEqual(
files["my_pkg.pc"], """prefix=/dummy_root_folder1
libdir=${prefix}/lib
includedir=${prefix}/include
Name: my_pkg
Description: My cool description
Version: 1.3
Libs: -L"${libdir}"
Cflags: -I"${includedir}" -Flag1=23 -DMYDEFINE1
""")
def aux_cmake_test_setup_test(self):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
generator = CMakeGenerator(conanfile)
aux_cmake_test_setup = generator.content
# extract the conan_basic_setup macro
macro = self._extract_macro("conan_basic_setup", aux_cmake_test_setup)
self.assertEqual("""macro(conan_basic_setup)
set(options TARGETS NO_OUTPUT_DIRS SKIP_RPATH KEEP_RPATHS SKIP_STD SKIP_FPIC)
cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
if(CONAN_EXPORTED)
conan_message(STATUS "Conan: called by CMake conan helper")
endif()
if(CONAN_IN_LOCAL_CACHE)
conan_message(STATUS "Conan: called inside local cache")
endif()
if(NOT ARGUMENTS_NO_OUTPUT_DIRS)
conan_message(STATUS "Conan: Adjusting output directories")
conan_output_dirs_setup()
endif()
if(NOT ARGUMENTS_TARGETS)
conan_message(STATUS "Conan: Using cmake global configuration")
conan_global_flags()
else()
conan_message(STATUS "Conan: Using cmake targets configuration")
conan_define_targets()
endif()
if(ARGUMENTS_SKIP_RPATH)
# Change by "DEPRECATION" or "SEND_ERROR" when we are ready
conan_message(WARNING "Conan: SKIP_RPATH is deprecated, it has been renamed to KEEP_RPATHS")
endif()
if(NOT ARGUMENTS_SKIP_RPATH AND NOT ARGUMENTS_KEEP_RPATHS)
# Parameter has renamed, but we keep the compatibility with old SKIP_RPATH
conan_message(STATUS "Conan: Adjusting default RPATHs Conan policies")
conan_set_rpath()
endif()
if(NOT ARGUMENTS_SKIP_STD)
conan_message(STATUS "Conan: Adjusting language standard")
conan_set_std()
endif()
if(NOT ARGUMENTS_SKIP_FPIC)
conan_set_fpic()
endif()
conan_check_compiler()
conan_set_libcxx()
conan_set_vs_runtime()
conan_set_find_paths()
conan_include_build_modules()
conan_set_find_library_paths()
endmacro()""", macro)
# extract the conan_set_find_paths macro
macro = self._extract_macro("conan_set_find_paths", aux_cmake_test_setup)
self.assertEqual("""macro(conan_set_find_paths)
# CMAKE_MODULE_PATH does not have Debug/Release config, but there are variables
# CONAN_CMAKE_MODULE_PATH_DEBUG to be used by the consumer
# CMake can find findXXX.cmake files in the root of packages
set(CMAKE_MODULE_PATH ${CONAN_CMAKE_MODULE_PATH} ${CMAKE_MODULE_PATH})
# Make find_package() to work
set(CMAKE_PREFIX_PATH ${CONAN_CMAKE_MODULE_PATH} ${CMAKE_PREFIX_PATH})
# Set the find root path (cross build)
set(CMAKE_FIND_ROOT_PATH ${CONAN_CMAKE_FIND_ROOT_PATH} ${CMAKE_FIND_ROOT_PATH})
if(CONAN_CMAKE_FIND_ROOT_PATH_MODE_PROGRAM)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ${CONAN_CMAKE_FIND_ROOT_PATH_MODE_PROGRAM})
endif()
if(CONAN_CMAKE_FIND_ROOT_PATH_MODE_LIBRARY)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ${CONAN_CMAKE_FIND_ROOT_PATH_MODE_LIBRARY})
endif()
if(CONAN_CMAKE_FIND_ROOT_PATH_MODE_INCLUDE)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ${CONAN_CMAKE_FIND_ROOT_PATH_MODE_INCLUDE})
endif()
endmacro()""", macro)
class CMakeCppInfoNamesTest(unittest.TestCase):
"""
Test cpp_info.names["generator"] values are applied in generators instead of the cpp_info.name
"""
def setUp(self):
self.conanfile = ConanFile(TestBufferConanOutput(), None)
settings = _MockSettings()
settings.build_type = "Debug"
self.conanfile.initialize(settings, EnvValues())
ref = ConanFileReference.loads("my_pkg/0.1@lasote/stables")
cpp_info = CppInfo("dummy_root_folder1")
cpp_info.name = "MyPkG"
cpp_info.names["cmake"] = "MyCMakeName"
cpp_info.names["cmake_multi"] = "MyCMakeMultiName"
cpp_info.names["cmake_find_package"] = "MyCMakeFindPackageName"
cpp_info.names["cmake_find_package_multi"] = "MyCMakeFindPackageMultiName"
self.conanfile.deps_cpp_info.update(cpp_info, ref.name)
ref = ConanFileReference.loads("my_pkg2/0.1@lasote/stables")
cpp_info = CppInfo("dummy_root_folder2")
cpp_info.name = "MyPkG2"
cpp_info.names["cmake"] = "MyCMakeName2"
cpp_info.names["cmake_multi"] = "MyCMakeMultiName2"
cpp_info.names["cmake_find_package"] = "MyCMakeFindPackageName2"
cpp_info.names["cmake_find_package_multi"] = "MyCMakeFindPackageMultiName2"
cpp_info.public_deps = ["my_pkg"]
self.conanfile.deps_cpp_info.update(cpp_info, ref.name)
def cmake_test(self):
generator = CMakeGenerator(self.conanfile)
content = generator.content
self.assertNotIn("MyPkG", content)
self.assertNotIn("MyPkG2", content)
self.assertIn('add_library(CONAN_PKG::MyCMakeName INTERFACE IMPORTED)', content)
self.assertIn('add_library(CONAN_PKG::MyCMakeName2 INTERFACE IMPORTED)', content)
def cmake_multi_test(self):
generator = CMakeMultiGenerator(self.conanfile)
content = generator.content
self.assertNotIn("MyPkG", content["conanbuildinfo_multi.cmake"])
self.assertNotIn("MyPkG2", content["conanbuildinfo_multi.cmake"])
self.assertIn('add_library(CONAN_PKG::MyCMakeMultiName INTERFACE IMPORTED)',
content["conanbuildinfo_multi.cmake"])
self.assertIn('add_library(CONAN_PKG::MyCMakeMultiName2 INTERFACE IMPORTED)',
content["conanbuildinfo_multi.cmake"])
def cmake_find_package_test(self):
generator = CMakeFindPackageGenerator(self.conanfile)
content = generator.content
self.assertIn("FindMyCMakeFindPackageName.cmake", content.keys())
self.assertIn("FindMyCMakeFindPackageName2.cmake", content.keys())
self.assertNotIn("MyPkG", content["FindMyCMakeFindPackageName.cmake"])
self.assertNotIn("MyPkG2", content["FindMyCMakeFindPackageName2.cmake"])
self.assertIn("add_library(MyCMakeFindPackageName::MyCMakeFindPackageName INTERFACE IMPORTED)",
content["FindMyCMakeFindPackageName.cmake"])
self.assertIn("add_library(MyCMakeFindPackageName2::MyCMakeFindPackageName2 INTERFACE IMPORTED)",
content["FindMyCMakeFindPackageName2.cmake"])
self.assertIn("find_dependency(MyCMakeFindPackageName REQUIRED)",
content["FindMyCMakeFindPackageName2.cmake"])
def cmake_find_package_multi_test(self):
generator = CMakeFindPackageMultiGenerator(self.conanfile)
content = generator.content
six.assertCountEqual(self, ['MyCMakeFindPackageMultiName2Targets.cmake',
'MyCMakeFindPackageMultiNameConfig.cmake',
'MyCMakeFindPackageMultiName2Config.cmake',
'MyCMakeFindPackageMultiNameTargets.cmake',
'MyCMakeFindPackageMultiNameTarget-debug.cmake',
'MyCMakeFindPackageMultiName2Target-debug.cmake',
'MyCMakeFindPackageMultiNameConfigVersion.cmake',
'MyCMakeFindPackageMultiName2ConfigVersion.cmake'],
content.keys())
self.assertNotIn("MyPkG", content["MyCMakeFindPackageMultiNameConfig.cmake"])
self.assertNotIn("MyPkG", content["MyCMakeFindPackageMultiName2Config.cmake"])
self.assertIn(
"add_library(MyCMakeFindPackageMultiName::MyCMakeFindPackageMultiName INTERFACE IMPORTED)",
content["MyCMakeFindPackageMultiNameTargets.cmake"])
self.assertIn(
"add_library(MyCMakeFindPackageMultiName2::MyCMakeFindPackageMultiName2 INTERFACE IMPORTED)",
content["MyCMakeFindPackageMultiName2Targets.cmake"])
self.assertIn("find_dependency(MyCMakeFindPackageMultiName REQUIRED NO_MODULE)",
content["MyCMakeFindPackageMultiName2Config.cmake"])
def b2_test(self):
settings = Settings.loads(default_settings_yml)
settings.os = "Linux"
settings.compiler = "gcc"
settings.compiler.version = "6.3"
settings.arch = "x86"
settings.build_type = "Release"
settings.cppstd = "gnu17"
conanfile = ConanFile(None, None)
conanfile.initialize(Settings({}), EnvValues())
conanfile.settings = settings
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo("dummy_root_folder1")
cpp_info.defines = ["MYDEFINE1"]
cpp_info.cflags.append("-Flag1=23")
cpp_info.version = "1.3"
cpp_info.description = "My cool description"
cpp_info.libs = ["MyLib1"]
conanfile.deps_cpp_info.update(cpp_info, ref.name)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo("dummy_root_folder2")
cpp_info.libs = ["MyLib2"]
cpp_info.defines = ["MYDEFINE2"]
cpp_info.version = "2.3"
cpp_info.exelinkflags = ["-exelinkflag"]
cpp_info.sharedlinkflags = ["-sharedlinkflag"]
cpp_info.cppflags = ["-cppflag"]
cpp_info.public_deps = ["MyPkg"]
cpp_info.lib_paths.extend(
["Path\\with\\slashes", "regular/path/to/dir"])
cpp_info.include_paths.extend(
["other\\Path\\with\\slashes", "other/regular/path/to/dir"])
conanfile.deps_cpp_info.update(cpp_info, ref.name)
generator = B2Generator(conanfile)
content = {
'conanbuildinfo.jam':
'''#|
B2 definitions for Conan packages. This is a generated file.
Edit the corresponding conanfile.txt instead.
|#
import path ;
import project ;
import modules ;
import feature ;
local base-project = [ project.current ] ;
local base-project-mod = [ $(base-project).project-module ] ;
local base-project-location = [ project.attribute $(base-project-mod) location ] ;
rule project-define ( id )
{
id = $(id:L) ;
local saved-project = [ modules.peek project : .base-project ] ;
local id-location = [ path.join $(base-project-location) $(id) ] ;
local id-mod = [ project.load $(id-location) : synthesize ] ;
project.initialize $(id-mod) : $(id-location) ;
project.inherit-attributes $(id-mod) : $(base-project-mod) ;
local attributes = [ project.attributes $(id-mod) ] ;
$(attributes).set parent-module : $(base-project-mod) : exact ;
modules.poke $(base-project-mod) : $(id)-mod : $(id-mod) ;
modules.poke [ CALLER_MODULE ] : $(id)-mod : $(id-mod) ;
modules.poke project : .base-project : $(saved-project) ;
IMPORT $(__name__)
: constant-if call-in-project
: $(id-mod)
: constant-if call-in-project ;
return $(id-mod) ;
}
rule constant-if ( name : value * )
{
if $(__define_constants__) && $(value)
{
call-in-project : constant $(name) : $(value) ;
modules.poke $(__name__) : $(name) : [ modules.peek $(base-project-mod) : $(name) ] ;
}
}
rule call-in-project ( project-mod ? : rule-name args * : * )
{
project-mod ?= $(base-project-mod) ;
project.push-current [ project.target $(project-mod) ] ;
local result = [ modules.call-in $(project-mod) :
$(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) : $(10) :
$(11) : $(12) : $(13) : $(14) : $(15) : $(16) : $(17) : $(18) :
$(19) ] ;
project.pop-current ;
return $(result) ;
}
rule include-conanbuildinfo ( cbi )
{
include $(cbi) ;
}
IMPORT $(__name__)
: project-define constant-if call-in-project include-conanbuildinfo
: $(base-project-mod)
: project-define constant-if call-in-project include-conanbuildinfo ;
if ! ( relwithdebinfo in [ feature.values variant ] )
{
variant relwithdebinfo : : <optimization>speed <debug-symbols>on <inlining>full <runtime-debugging>off ;
}
if ! ( minsizerel in [ feature.values variant ] )
{
variant minsizerel : : <optimization>space <debug-symbols>off <inlining>full <runtime-debugging>off ;
}
local __conanbuildinfo__ = [ GLOB $(__file__:D) : conanbuildinfo-*.jam : downcase ] ;
{
local __define_constants__ = yes ;
for local __cbi__ in $(__conanbuildinfo__)
{
call-in-project : include-conanbuildinfo $(__cbi__) ;
}
}
# mypkg
# mypkg
project-define mypkg ;
# mypkg2
# mypkg2
project-define mypkg2 ;
{
local __define_targets__ = yes ;
for local __cbi__ in $(__conanbuildinfo__)
{
call-in-project : include-conanbuildinfo $(__cbi__) ;
}
}
''',
'conanbuildinfo-316f2f0b155dc874a672d40d98d93f95.jam':
'''#|
B2 definitions for Conan packages. This is a generated file.
Edit the corresponding conanfile.txt instead.
|#
# global
constant-if rootpath(conan,32,x86,17,gnu,linux,gcc-6.3,release) :
""
;
constant-if includedirs(conan,32,x86,17,gnu,linux,gcc-6.3,release) :
"other/Path/with/slashes"
"other/regular/path/to/dir"
;
constant-if libdirs(conan,32,x86,17,gnu,linux,gcc-6.3,release) :
"Path/with/slashes"
"regular/path/to/dir"
;
constant-if defines(conan,32,x86,17,gnu,linux,gcc-6.3,release) :
"MYDEFINE2"
"MYDEFINE1"
;
constant-if cppflags(conan,32,x86,17,gnu,linux,gcc-6.3,release) :
"-cppflag"
;
constant-if cflags(conan,32,x86,17,gnu,linux,gcc-6.3,release) :
"-Flag1=23"
;
constant-if sharedlinkflags(conan,32,x86,17,gnu,linux,gcc-6.3,release) :
"-sharedlinkflag"
;
constant-if exelinkflags(conan,32,x86,17,gnu,linux,gcc-6.3,release) :
"-exelinkflag"
;
constant-if requirements(conan,32,x86,17,gnu,linux,gcc-6.3,release) :
<address-model>32
<architecture>x86
<cxxstd>17
<cxxstd:dialect>gnu
<target-os>linux
<toolset>gcc-6.3
<variant>release
;
constant-if usage-requirements(conan,32,x86,17,gnu,linux,gcc-6.3,release) :
<include>$(includedirs(conan,32,x86,17,gnu,linux,gcc-6.3,release))
<define>$(defines(conan,32,x86,17,gnu,linux,gcc-6.3,release))
<cflags>$(cflags(conan,32,x86,17,gnu,linux,gcc-6.3,release))
<cxxflags>$(cppflags(conan,32,x86,17,gnu,linux,gcc-6.3,release))
<link>shared:<linkflags>$(sharedlinkflags(conan,32,x86,17,gnu,linux,gcc-6.3,release))
;
# mypkg
constant-if rootpath(mypkg,32,x86,17,gnu,linux,gcc-6.3,release) :
"dummy_root_folder1"
;
constant-if defines(mypkg,32,x86,17,gnu,linux,gcc-6.3,release) :
"MYDEFINE1"
;
constant-if cflags(mypkg,32,x86,17,gnu,linux,gcc-6.3,release) :
"-Flag1=23"
;
constant-if requirements(mypkg,32,x86,17,gnu,linux,gcc-6.3,release) :
<address-model>32
<architecture>x86
<cxxstd>17
<cxxstd:dialect>gnu
<target-os>linux
<toolset>gcc-6.3
<variant>release
;
constant-if usage-requirements(mypkg,32,x86,17,gnu,linux,gcc-6.3,release) :
<include>$(includedirs(mypkg,32,x86,17,gnu,linux,gcc-6.3,release))
<define>$(defines(mypkg,32,x86,17,gnu,linux,gcc-6.3,release))
<cflags>$(cflags(mypkg,32,x86,17,gnu,linux,gcc-6.3,release))
<cxxflags>$(cppflags(mypkg,32,x86,17,gnu,linux,gcc-6.3,release))
<link>shared:<linkflags>$(sharedlinkflags(mypkg,32,x86,17,gnu,linux,gcc-6.3,release))
;
# mypkg2
constant-if rootpath(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release) :
"dummy_root_folder2"
;
constant-if includedirs(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release) :
"other/Path/with/slashes"
"other/regular/path/to/dir"
;
constant-if libdirs(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release) :
"Path/with/slashes"
"regular/path/to/dir"
;
constant-if defines(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release) :
"MYDEFINE2"
;
constant-if cppflags(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release) :
"-cppflag"
;
constant-if sharedlinkflags(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release) :
"-sharedlinkflag"
;
constant-if exelinkflags(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release) :
"-exelinkflag"
;
constant-if requirements(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release) :
<address-model>32
<architecture>x86
<cxxstd>17
<cxxstd:dialect>gnu
<target-os>linux
<toolset>gcc-6.3
<variant>release
;
constant-if usage-requirements(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release) :
<include>$(includedirs(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release))
<define>$(defines(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release))
<cflags>$(cflags(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release))
<cxxflags>$(cppflags(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release))
<link>shared:<linkflags>$(sharedlinkflags(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release))
;
# mypkg
if $(__define_targets__) {
call-in-project $(mypkg-mod) : lib MyLib1
:
: <name>MyLib1 <search>$(libdirs(mypkg,32,x86,17,gnu,linux,gcc-6.3,release)) $(requirements(mypkg,32,x86,17,gnu,linux,gcc-6.3,release))
:
: $(usage-requirements(mypkg,32,x86,17,gnu,linux,gcc-6.3,release)) ;
call-in-project $(mypkg-mod) : explicit MyLib1 ; }
if $(__define_targets__) {
call-in-project $(mypkg-mod) : alias libs
: MyLib1
: $(requirements(mypkg,32,x86,17,gnu,linux,gcc-6.3,release))
:
: $(usage-requirements(mypkg,32,x86,17,gnu,linux,gcc-6.3,release)) ;
call-in-project $(mypkg-mod) : explicit libs ; }
# mypkg2
if $(__define_targets__) {
call-in-project $(mypkg2-mod) : lib MyLib2
:
: <name>MyLib2 <search>$(libdirs(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release)) $(requirements(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release))
:
: $(usage-requirements(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release)) ;
call-in-project $(mypkg2-mod) : explicit MyLib2 ; }
if $(__define_targets__) {
call-in-project $(mypkg2-mod) : alias libs
: MyLib2
: $(requirements(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release))
:
: $(usage-requirements(mypkg2,32,x86,17,gnu,linux,gcc-6.3,release)) ;
call-in-project $(mypkg2-mod) : explicit libs ; }
''',
}
for ck, cv in generator.content.items():
self.assertEquals(cv, content[ck])
def valid_xml_test(self, use_toolset):
tempdir = temp_folder()
with chdir(tempdir):
settings = Settings.loads(default_settings_yml)
settings.os = "Windows"
settings.compiler = "Visual Studio"
settings.compiler.version = "11"
settings.compiler.runtime = "MD"
if use_toolset:
settings.compiler.toolset = "v110"
conanfile = ConanFile(None, None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@user/testing")
cpp_info = CppInfo("dummy_root_folder1")
conanfile.deps_cpp_info.update(cpp_info, ref.name)
ref = ConanFileReference.loads("My.Fancy-Pkg_2/0.1@user/testing")
cpp_info = CppInfo("dummy_root_folder2")
conanfile.deps_cpp_info.update(cpp_info, ref.name)
settings.arch = "x86"
settings.build_type = "Debug"
conanfile.settings = settings
generator = VisualStudioMultiGenerator(conanfile)
generator.output_path = ""
content = generator.content
self.assertEqual(2, len(content))
self.assertIn('conanbuildinfo_multi.props', content.keys())
self.assertIn('conanbuildinfo_debug_win32_v110.props',
content.keys())
content_multi = content['conanbuildinfo_multi.props']
self.assertIn(
"<Import Condition=\"'$(Configuration)' == 'Debug' "
"And '$(Platform)' == 'Win32' "
"And '$(PlatformToolset)' == 'v110'\" "
"Project=\"conanbuildinfo_debug_win32_v110.props\"/>",
content_multi)
with open('conanbuildinfo_multi.props', 'w') as f:
f.write(content_multi)
settings.arch = "x86_64"
settings.build_type = "Release"
settings.compiler.version = "15"
settings.compiler.toolset = "v141"
conanfile.settings = settings
generator = VisualStudioMultiGenerator(conanfile)
generator.output_path = ""
content = generator.content
self.assertEqual(2, len(content))
self.assertIn('conanbuildinfo_multi.props', content.keys())
self.assertIn('conanbuildinfo_release_x64_v141.props',
content.keys())
content_multi = content['conanbuildinfo_multi.props']
self.assertIn(
"<Import Condition=\"'$(Configuration)' == 'Debug' "
"And '$(Platform)' == 'Win32' "
"And '$(PlatformToolset)' == 'v110'\" "
"Project=\"conanbuildinfo_debug_win32_v110.props\"/>",
content_multi)
self.assertIn(
"<Import Condition=\"'$(Configuration)' == 'Release' "
"And '$(Platform)' == 'x64' "
"And '$(PlatformToolset)' == 'v141'\" "
"Project=\"conanbuildinfo_release_x64_v141.props\"/>",
content_multi)
os.unlink('conanbuildinfo_multi.props')
def variables_setup_test(self):
tmp_folder1 = temp_folder()
tmp_folder2 = temp_folder()
save(os.path.join(tmp_folder1, "include1", "file.h"), "")
save(os.path.join(tmp_folder2, "include2", "file.h"), "")
save(os.path.join(tmp_folder1, "lib1", "file.a"), "")
save(os.path.join(tmp_folder2, "lib2", "file.a"), "")
save(os.path.join(tmp_folder1, "bin1", "file.bin"), "")
save(os.path.join(tmp_folder2, "bin2", "file.bin"), "")
conanfile = ConanFile(None, None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg1/0.1@lasote/stables")
cpp_info = CppInfo(tmp_folder1)
cpp_info.defines = ["MYDEFINE1"]
cpp_info.includedirs = ['include1']
cpp_info.libdirs = ['lib1']
cpp_info.libs = ['libfoo']
cpp_info.bindirs = ['bin1']
cpp_info.version = "0.1"
cpp_info.cflags = ['-fgimple']
cpp_info.cppflags = ['-fdollars-in-identifiers']
cpp_info.sharedlinkflags = ['-framework Cocoa']
cpp_info.exelinkflags = ['-framework QuartzCore']
conanfile.deps_cpp_info.update(cpp_info, ref.name)
ref = ConanFileReference.loads("MyPkg2/3.2.3@lasote/stables")
cpp_info = CppInfo(tmp_folder2)
cpp_info.defines = ["MYDEFINE2"]
cpp_info.includedirs = ['include2']
cpp_info.libdirs = ['lib2']
cpp_info.libs = ['libbar']
cpp_info.bindirs = ['bin2']
cpp_info.version = "3.2.3"
cpp_info.cflags = ['-fno-asm']
cpp_info.cppflags = ['-pthread']
cpp_info.sharedlinkflags = ['-framework AudioFoundation']
cpp_info.exelinkflags = ['-framework VideoToolbox']
conanfile.deps_cpp_info.update(cpp_info, ref.name)
generator = MakeGenerator(conanfile)
content = generator.content
content_template = """
CONAN_ROOT_MYPKG1 ?= \\
{conan_root_mypkg1}
CONAN_SYSROOT_MYPKG1 ?= \\
CONAN_INCLUDE_PATHS_MYPKG1 += \\
{conan_include_paths_mypkg1}
CONAN_LIB_PATHS_MYPKG1 += \\
{conan_lib_paths_mypkg1}
CONAN_BIN_PATHS_MYPKG1 += \\
{conan_bin_paths_mypkg1}
CONAN_BUILD_PATHS_MYPKG1 += \\
{conan_build_paths_mypkg1}
CONAN_RES_PATHS_MYPKG1 += \\
CONAN_LIBS_MYPKG1 += \\
libfoo
CONAN_DEFINES_MYPKG1 += \\
MYDEFINE1
CONAN_CFLAGS_MYPKG1 += \\
-fgimple
CONAN_CPPFLAGS_MYPKG1 += \\
-fdollars-in-identifiers
CONAN_SHAREDLINKFLAGS_MYPKG1 += \\
-framework Cocoa
CONAN_EXELINKFLAGS_MYPKG1 += \\
-framework QuartzCore
CONAN_ROOT_MYPKG2 ?= \\
{conan_root_mypkg2}
CONAN_SYSROOT_MYPKG2 ?= \\
CONAN_INCLUDE_PATHS_MYPKG2 += \\
{conan_include_paths_mypkg2}
CONAN_LIB_PATHS_MYPKG2 += \\
{conan_lib_paths_mypkg2}
CONAN_BIN_PATHS_MYPKG2 += \\
{conan_bin_paths_mypkg2}
CONAN_BUILD_PATHS_MYPKG2 += \\
{conan_build_paths_mypkg2}
CONAN_RES_PATHS_MYPKG2 += \\
CONAN_LIBS_MYPKG2 += \\
libbar
CONAN_DEFINES_MYPKG2 += \\
MYDEFINE2
CONAN_CFLAGS_MYPKG2 += \\
-fno-asm
CONAN_CPPFLAGS_MYPKG2 += \\
-pthread
CONAN_SHAREDLINKFLAGS_MYPKG2 += \\
-framework AudioFoundation
CONAN_EXELINKFLAGS_MYPKG2 += \\
-framework VideoToolbox
CONAN_ROOTPATH += \\
$(CONAN_ROOTPATH_MYPKG1) \\
$(CONAN_ROOTPATH_MYPKG2)
CONAN_SYSROOT += \\
$(CONAN_SYSROOT_MYPKG1) \\
$(CONAN_SYSROOT_MYPKG2)
CONAN_INCLUDE_PATHS += \\
$(CONAN_INCLUDE_PATHS_MYPKG1) \\
$(CONAN_INCLUDE_PATHS_MYPKG2)
CONAN_LIB_PATHS += \\
$(CONAN_LIB_PATHS_MYPKG1) \\
$(CONAN_LIB_PATHS_MYPKG2)
CONAN_BIN_PATHS += \\
$(CONAN_BIN_PATHS_MYPKG1) \\
$(CONAN_BIN_PATHS_MYPKG2)
CONAN_BUILD_PATHS += \\
$(CONAN_BUILD_PATHS_MYPKG1) \\
$(CONAN_BUILD_PATHS_MYPKG2)
CONAN_RES_PATHS += \\
$(CONAN_RES_PATHS_MYPKG1) \\
$(CONAN_RES_PATHS_MYPKG2)
CONAN_LIBS += \\
$(CONAN_LIBS_MYPKG1) \\
$(CONAN_LIBS_MYPKG2)
CONAN_DEFINES += \\
$(CONAN_DEFINES_MYPKG1) \\
$(CONAN_DEFINES_MYPKG2)
CONAN_CFLAGS += \\
$(CONAN_CFLAGS_MYPKG1) \\
$(CONAN_CFLAGS_MYPKG2)
CONAN_CPPFLAGS += \\
$(CONAN_CPPFLAGS_MYPKG1) \\
$(CONAN_CPPFLAGS_MYPKG2)
CONAN_SHAREDLINKFLAGS += \\
$(CONAN_SHAREDLINKFLAGS_MYPKG1) \\
$(CONAN_SHAREDLINKFLAGS_MYPKG2)
CONAN_EXELINKFLAGS += \\
$(CONAN_EXELINKFLAGS_MYPKG1) \\
$(CONAN_EXELINKFLAGS_MYPKG2)
"""
root1 = tmp_folder1.replace('\\', '/')
root2 = tmp_folder2.replace('\\', '/')
inc1 = os.path.join(tmp_folder1, 'include1').replace('\\', '/')
inc2 = os.path.join(tmp_folder2, 'include2').replace('\\', '/')
lib1 = os.path.join(tmp_folder1, 'lib1').replace('\\', '/')
lib2 = os.path.join(tmp_folder2, 'lib2').replace('\\', '/')
bin1 = os.path.join(tmp_folder1, 'bin1').replace('\\', '/')
bin2 = os.path.join(tmp_folder2, 'bin2').replace('\\', '/')
expected_content = content_template.format(
conan_root_mypkg1=root1,
conan_include_paths_mypkg1=inc1,
conan_lib_paths_mypkg1=lib1,
conan_bin_paths_mypkg1=bin1,
conan_build_paths_mypkg1=root1 + "/",
conan_root_mypkg2=root2,
conan_include_paths_mypkg2=inc2,
conan_lib_paths_mypkg2=lib2,
conan_bin_paths_mypkg2=bin2,
conan_build_paths_mypkg2=root2 + "/")
self.assertIn(expected_content, content)
class CMakeCppInfoNameTest(unittest.TestCase):
"""
Test cpp_info.name values are applied in generators instead of the reference name
"""
def setUp(self):
self.conanfile = ConanFile(Mock(), None)
settings = _MockSettings(build_type="Debug")
self.conanfile.initialize(settings, EnvValues())
ref = ConanFileReference.loads("my_pkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.name = "MyPkG"
self.conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("my_pkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.name = "MyPkG2"
cpp_info.public_deps = ["my_pkg"]
self.conanfile.deps_cpp_info.add(ref.name, cpp_info)
def test_cmake(self):
generator = CMakeGenerator(self.conanfile)
content = generator.content
self.assertIn("set(CONAN_DEPENDENCIES my_pkg my_pkg2)", content)
content = content.replace("set(CONAN_DEPENDENCIES my_pkg my_pkg2)", "")
self.assertNotIn("my_pkg", content)
self.assertNotIn("MY_PKG", content)
self.assertIn('add_library(CONAN_PKG::MyPkG INTERFACE IMPORTED)',
content)
self.assertIn('add_library(CONAN_PKG::MyPkG2 INTERFACE IMPORTED)',
content)
self.assertNotIn('CONAN_PKG::my_pkg', content)
self.assertNotIn('CONAN_PKG::my_pkg2', content)
def test_cmake_multi(self):
generator = CMakeMultiGenerator(self.conanfile)
content = generator.content
self.assertIn("set(CONAN_DEPENDENCIES_DEBUG my_pkg my_pkg2)",
content["conanbuildinfo_debug.cmake"])
self.assertNotIn("my_pkg", content["conanbuildinfo_multi.cmake"])
self.assertNotIn("MY_PKG", content["conanbuildinfo_multi.cmake"])
self.assertIn('add_library(CONAN_PKG::MyPkG INTERFACE IMPORTED)',
content["conanbuildinfo_multi.cmake"])
self.assertIn('add_library(CONAN_PKG::MyPkG2 INTERFACE IMPORTED)',
content["conanbuildinfo_multi.cmake"])
self.assertNotIn('CONAN_PKG::my_pkg',
content["conanbuildinfo_multi.cmake"])
self.assertNotIn('CONAN_PKG::my_pkg2',
content["conanbuildinfo_multi.cmake"])
def test_cmake_find_package(self):
generator = CMakeFindPackageGenerator(self.conanfile)
content = generator.content
self.assertIn("FindMyPkG.cmake", content.keys())
self.assertIn("FindMyPkG2.cmake", content.keys())
self.assertNotIn("my_pkg", content["FindMyPkG.cmake"])
self.assertNotIn("MY_PKG", content["FindMyPkG.cmake"])
self.assertNotIn("my_pkg", content["FindMyPkG2.cmake"])
self.assertNotIn("MY_PKG", content["FindMyPkG2.cmake"])
self.assertIn("add_library(MyPkG::MyPkG INTERFACE IMPORTED)",
content["FindMyPkG.cmake"])
self.assertIn("add_library(MyPkG2::MyPkG2 INTERFACE IMPORTED)",
content["FindMyPkG2.cmake"])
self.assertIn("find_dependency(MyPkG REQUIRED)",
content["FindMyPkG2.cmake"])
def test_cmake_find_package_multi(self):
generator = CMakeFindPackageMultiGenerator(self.conanfile)
content = generator.content
six.assertCountEqual(self, [
'MyPkG2Targets.cmake', 'MyPkGConfig.cmake', 'MyPkG2Config.cmake',
'MyPkGTargets.cmake', 'MyPkGTarget-debug.cmake',
'MyPkG2Target-debug.cmake', 'MyPkGConfigVersion.cmake',
'MyPkG2ConfigVersion.cmake'
], content.keys())
self.assertNotIn("my_pkg", content["MyPkGConfig.cmake"])
self.assertNotIn("MY_PKG", content["MyPkGConfig.cmake"])
self.assertNotIn("my_pkg", content["MyPkG2Config.cmake"])
self.assertNotIn("MY_PKG", content["MyPkG2Config.cmake"])
self.assertIn("add_library(MyPkG::MyPkG INTERFACE IMPORTED)",
content["MyPkGTargets.cmake"])
self.assertIn("add_library(MyPkG2::MyPkG2 INTERFACE IMPORTED)",
content["MyPkG2Targets.cmake"])
self.assertIn("find_dependency(MyPkG REQUIRED NO_MODULE)",
content["MyPkG2Config.cmake"])
class PremakeGeneratorTest(unittest.TestCase):
content_template = textwrap.dedent("""\
#!lua
conan_build_type = "None"
conan_arch = "None"
conan_includedirs = {{"{include1}",
"{include2}"}}
conan_libdirs = {{"{lib1}",
"{lib2}"}}
conan_bindirs = {{"{bin1}",
"{bin2}"}}
conan_libs = {{"libfoo", "libbar"}}
conan_system_libs = {{"syslib1", "syslib2"}}
conan_defines = {{"MYDEFINE2", "MYDEFINE1"}}
conan_cxxflags = {{"-march=native", "-fPIE"}}
conan_cflags = {{"-mtune=native", "-fPIC"}}
conan_sharedlinkflags = {{"-framework AudioFoundation", "-framework \\\"Some Spaced Framework\\\"", "-framework Cocoa"}}
conan_exelinkflags = {{"-framework VideoToolbox", "-framework \\\"Other Spaced Framework\\\"", "-framework QuartzCore"}}
conan_includedirs_MyPkg1 = {{"{include1}"}}
conan_libdirs_MyPkg1 = {{"{lib1}"}}
conan_bindirs_MyPkg1 = {{"{bin1}"}}
conan_libs_MyPkg1 = {{"libfoo"}}
conan_system_libs_MyPkg1 = {{"syslib1"}}
conan_defines_MyPkg1 = {{"MYDEFINE1"}}
conan_cxxflags_MyPkg1 = {{"-fPIE"}}
conan_cflags_MyPkg1 = {{"-fPIC"}}
conan_sharedlinkflags_MyPkg1 = {{"-framework Cocoa"}}
conan_exelinkflags_MyPkg1 = {{"-framework QuartzCore"}}
conan_rootpath_MyPkg1 = "{root1}"
conan_includedirs_MyPkg2 = {{"{include2}"}}
conan_libdirs_MyPkg2 = {{"{lib2}"}}
conan_bindirs_MyPkg2 = {{"{bin2}"}}
conan_libs_MyPkg2 = {{"libbar"}}
conan_system_libs_MyPkg2 = {{"syslib2"}}
conan_defines_MyPkg2 = {{"MYDEFINE2"}}
conan_cxxflags_MyPkg2 = {{"-march=native"}}
conan_cflags_MyPkg2 = {{"-mtune=native"}}
conan_sharedlinkflags_MyPkg2 = {{"-framework AudioFoundation", "-framework \\\"Some Spaced Framework\\\""}}
conan_exelinkflags_MyPkg2 = {{"-framework VideoToolbox", "-framework \\\"Other Spaced Framework\\\""}}
conan_rootpath_MyPkg2 = "{root2}"
function conan_basic_setup()
configurations{{conan_build_type}}
architecture(conan_arch)
includedirs{{conan_includedirs}}
libdirs{{conan_libdirs}}
links{{conan_libs}}
links{{conan_system_libs}}
defines{{conan_defines}}
bindirs{{conan_bindirs}}
end
""")
def setUp(self):
self.tmp_folder1 = temp_folder()
self.tmp_folder2 = temp_folder()
save(os.path.join(self.tmp_folder1, "include1", "file.h"), "")
save(os.path.join(self.tmp_folder2, "include2", "file.h"), "")
save(os.path.join(self.tmp_folder1, "lib1", "file.a"), "")
save(os.path.join(self.tmp_folder2, "lib2", "file.a"), "")
save(os.path.join(self.tmp_folder1, "bin1", "file.bin"), "")
save(os.path.join(self.tmp_folder2, "bin2", "file.bin"), "")
self.conanfile = ConanFile(TestBufferConanOutput(), None)
self.conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg1/0.1@lasote/stables")
cpp_info = CppInfo(self.tmp_folder1)
cpp_info.defines = ["MYDEFINE1"]
cpp_info.includedirs = ['include1']
cpp_info.libdirs = ['lib1']
cpp_info.libs = ['libfoo']
cpp_info.system_libs = ['syslib1']
cpp_info.bindirs = ['bin1']
cpp_info.version = "0.1"
cpp_info.cflags = ['-fPIC']
cpp_info.cxxflags = ['-fPIE']
cpp_info.sharedlinkflags = ['-framework Cocoa']
cpp_info.exelinkflags = ['-framework QuartzCore']
self.conanfile.deps_cpp_info.update(cpp_info, ref.name)
ref = ConanFileReference.loads("MyPkg2/3.2.3@lasote/stables")
cpp_info = CppInfo(self.tmp_folder2)
cpp_info.defines = ["MYDEFINE2"]
cpp_info.includedirs = ['include2']
cpp_info.libdirs = ['lib2']
cpp_info.libs = ['libbar']
cpp_info.system_libs = ['syslib2']
cpp_info.bindirs = ['bin2']
cpp_info.version = "3.2.3"
cpp_info.cflags = ['-mtune=native']
cpp_info.cxxflags = ['-march=native']
cpp_info.sharedlinkflags = [
'-framework AudioFoundation', '-framework "Some Spaced Framework"'
]
cpp_info.exelinkflags = [
'-framework VideoToolbox', '-framework "Other Spaced Framework"'
]
self.conanfile.deps_cpp_info.update(cpp_info, ref.name)
def test_variables_content(self):
generator = PremakeGenerator(self.conanfile)
content = generator.content
inc1 = os.path.join(self.tmp_folder1, 'include1').replace('\\', '/')
inc2 = os.path.join(self.tmp_folder2, 'include2').replace('\\', '/')
lib1 = os.path.join(self.tmp_folder1, 'lib1').replace('\\', '/')
lib2 = os.path.join(self.tmp_folder2, 'lib2').replace('\\', '/')
bin1 = os.path.join(self.tmp_folder1, 'bin1').replace('\\', '/')
bin2 = os.path.join(self.tmp_folder2, 'bin2').replace('\\', '/')
root1 = self.tmp_folder1.replace('\\', '/')
root2 = self.tmp_folder2.replace('\\', '/')
expected_content = self.content_template.format(include1=inc1,
include2=inc2,
lib1=lib1,
lib2=lib2,
bin1=bin1,
bin2=bin2,
root1=root1,
root2=root2)
self.assertEqual(expected_content, content)
def test_idempotent(self):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
# Add some cpp_info
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.names["txt"] = "mypkg1-txt"
cpp_info.version = ref.version
cpp_info.defines = ["MYDEFINE1"]
cpp_info.cxxflags = ["-cxxflag_parent"]
cpp_info.includedirs = ["mypkg1/include"]
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.defines = ["MYDEFINE2"]
cpp_info.cxxflags = ["-cxxflag_dep"]
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add(ref.name, cpp_info)
# Add env_info
env_info = EnvInfo()
env_info.VAR1 = "value1"
env_info.PATH.append("path-extended")
conanfile.deps_env_info.update(env_info, "my_pkg")
env_info = EnvInfo()
env_info.VAR1 = "other-value1"
env_info.PATH.append("other-path-extended")
conanfile.deps_env_info.update(env_info, "other-pkg")
# Add user_info for HOST
user_info = UserInfo()
user_info.VAR1 = "value1"
conanfile.deps_user_info["my_pkg"] = user_info
user_info = UserInfo()
user_info.VAR1 = "other-value1"
conanfile.deps_user_info["other-pkg"] = user_info
# Add user_info for BUILD
conanfile.user_info_build = DepsUserInfo()
user_info = UserInfo()
user_info.VAR1 = "value1"
conanfile.user_info_build["build_pkg"] = user_info
user_info = UserInfo()
user_info.VAR1 = "other-value1"
conanfile.user_info_build["other-build-pkg"] = user_info
master_content = TXTGenerator(conanfile).content
after_cpp_info, after_user_info, after_env_info, after_user_info_build = \
TXTGenerator.loads(master_content, filter_empty=False)
# Assign them to a different conanfile
other_conanfile = ConanFile(TestBufferConanOutput(), None)
other_conanfile.initialize(Settings({}), EnvValues())
other_conanfile.deps_cpp_info = after_cpp_info
other_conanfile.deps_env_info = after_env_info
other_conanfile.deps_user_info = after_user_info
other_conanfile.user_info_build = after_user_info_build
after_content = TXTGenerator(other_conanfile).content
self.assertListEqual(master_content.splitlines(),
after_content.splitlines())
def variables_setup_test(self):
tmp_folder1 = temp_folder()
tmp_folder2 = temp_folder()
save(os.path.join(tmp_folder1, "include1", "file.h"), "")
save(os.path.join(tmp_folder2, "include2", "file.h"), "")
save(os.path.join(tmp_folder1, "lib1", "file.a"), "")
save(os.path.join(tmp_folder2, "lib2", "file.a"), "")
save(os.path.join(tmp_folder1, "bin1", "file.bin"), "")
save(os.path.join(tmp_folder2, "bin2", "file.bin"), "")
conanfile = ConanFile(None, None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg1/0.1@lasote/stables")
cpp_info = CppInfo(tmp_folder1)
cpp_info.defines = ["MYDEFINE1"]
cpp_info.includedirs = ['include1']
cpp_info.libdirs = ['lib1']
cpp_info.libs = ['libfoo']
cpp_info.bindirs = ['bin1']
cpp_info.version = "0.1"
cpp_info.cflags = ['-fPIC']
cpp_info.cppflags = ['-fPIE']
cpp_info.sharedlinkflags = ['-framework Cocoa']
cpp_info.exelinkflags = ['-framework QuartzCore']
conanfile.deps_cpp_info.update(cpp_info, ref.name)
ref = ConanFileReference.loads("MyPkg2/3.2.3@lasote/stables")
cpp_info = CppInfo(tmp_folder2)
cpp_info.defines = ["MYDEFINE2"]
cpp_info.includedirs = ['include2']
cpp_info.libdirs = ['lib2']
cpp_info.libs = ['libbar']
cpp_info.bindirs = ['bin2']
cpp_info.version = "3.2.3"
cpp_info.cflags = ['-mtune=native']
cpp_info.cppflags = ['-march=native']
cpp_info.sharedlinkflags = ['-framework AudioFoundation']
cpp_info.exelinkflags = ['-framework VideoToolbox']
conanfile.deps_cpp_info.update(cpp_info, ref.name)
generator = PremakeGenerator(conanfile)
content = generator.content
self.assertIn('conan_cppdefines = {"MYDEFINE2", "MYDEFINE1"}', content)
self.assertIn('conan_cppdefines_MyPkg1 = {"MYDEFINE1"}', content)
self.assertIn('conan_cppdefines_MyPkg2 = {"MYDEFINE2"}', content)
inc1 = os.path.join(tmp_folder1, 'include1').replace('\\', '/')
inc2 = os.path.join(tmp_folder2, 'include2').replace('\\', '/')
self.assertIn('conan_includedirs = {"%s",\n"%s"}' % (inc1, inc2),
content)
self.assertIn('conan_includedirs_MyPkg1 = {"%s"}' % inc1, content)
self.assertIn('conan_includedirs_MyPkg2 = {"%s"}' % inc2, content)
lib1 = os.path.join(tmp_folder1, 'lib1').replace('\\', '/')
lib2 = os.path.join(tmp_folder2, 'lib2').replace('\\', '/')
self.assertIn('conan_libdirs = {"%s",\n"%s"}' % (lib1, lib2), content)
self.assertIn('conan_libdirs_MyPkg1 = {"%s"}' % lib1, content)
self.assertIn('conan_libdirs_MyPkg2 = {"%s"}' % lib2, content)
bin1 = os.path.join(tmp_folder1, 'bin1').replace('\\', '/')
bin2 = os.path.join(tmp_folder2, 'bin2').replace('\\', '/')
self.assertIn('conan_bindirs = {"%s",\n"%s"}' % (bin1, bin2), content)
self.assertIn('conan_bindirs_MyPkg1 = {"%s"}' % bin1, content)
self.assertIn('conan_bindirs_MyPkg2 = {"%s"}' % bin2, content)
self.assertIn('conan_libs = {"libfoo", "libbar"}', content)
self.assertIn('conan_libs_MyPkg1 = {"libfoo"}', content)
self.assertIn('conan_libs_MyPkg2 = {"libbar"}', content)
self.assertIn('conan_cflags = {"-mtune=native", "-fPIC"}', content)
self.assertIn('conan_cflags_MyPkg1 = {"-fPIC"}', content)
self.assertIn('conan_cflags_MyPkg2 = {"-mtune=native"}', content)
self.assertIn('conan_cppflags = {"-march=native", "-fPIE"}', content)
self.assertIn('conan_cppflags_MyPkg1 = {"-fPIE"}', content)
self.assertIn('conan_cppflags_MyPkg2 = {"-march=native"}', content)
self.assertIn(
'conan_sharedlinkflags = {"-framework AudioFoundation", "-framework Cocoa"}',
content)
self.assertIn('conan_sharedlinkflags_MyPkg1 = {"-framework Cocoa"}',
content)
self.assertIn(
'conan_sharedlinkflags_MyPkg2 = {"-framework AudioFoundation"}',
content)
self.assertIn(
'conan_exelinkflags = {"-framework VideoToolbox", "-framework QuartzCore"}',
content)
self.assertIn('conan_exelinkflags_MyPkg1 = {"-framework QuartzCore"}',
content)
self.assertIn(
'conan_exelinkflags_MyPkg2 = {"-framework VideoToolbox"}', content)
def test_toolchain_linux(self, build_type, arch, cppstd, libcxx, shared,
fpic):
settings_mock = _MockSettings(build_type, arch, cppstd, libcxx)
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.options = {"shared": [True, False], "fPIC": [True, False]}
conanfile.default_options = {"shared": shared, "fPIC": fpic}
conanfile.initialize(settings_mock, EnvValues())
toolchain = MakeToolchain(conanfile)
content = toolchain.content
expected_template = Template(
textwrap.dedent("""
# Conan generated toolchain file
ifndef CONAN_TOOLCHAIN_INCLUDED
CONAN_TOOLCHAIN_INCLUDED = TRUE
CONAN_TC_BUILD_TYPE = {{build_type}}
CONAN_TC_OS_HOST = None
CONAN_TC_ARCH_HOST = {{arch_host}}
CONAN_TC_TRIPLET_HOST = False
CONAN_TC_OS_BUILD = Linux
CONAN_TC_ARCH_BUILD = {{arch_build}}
CONAN_TC_TRIPLET_BUILD = False
CONAN_TC_OS_TARGET = None
CONAN_TC_ARCH_TARGET = None
CONAN_TC_TRIPLET_TARGET = None
CONAN_TC_COMPILER = {{compiler}}
CONAN_TC_COMPILER_VERSION = {{compiler_version}}
CONAN_TC_COMPILER_RUNTIME = None
CONAN_TC_LIBCXX = {{libcxx}}
CONAN_TC_CPPSTD_FLAG = {{cppstd_flag}}
CONAN_TC_ARCH_FLAG = {{arch_flag}}
CONAN_TC_BUILD_TYPE_FLAGS = {{build_type_flags}}
CONAN_TC_DEFINES ={{preserved_space}}
CONAN_TC_SET_LIBCXX = True
CONAN_TC_SET_CPPSTD = True
CONAN_TC_SET_ARCH = True
CONAN_TC_SET_FPIC = {{set_fpic}}
CONAN_TC_SET_SHARED = {{set_shared}}
CONAN_TC_CFLAGS += $(CONAN_TC_BUILD_TYPE_FLAGS)
CONAN_TC_CXXFLAGS += $(CONAN_TC_BUILD_TYPE_FLAGS)
ifeq ($(CONAN_TC_BUILD_TYPE),Release)
CONAN_TC_DEFINES += NDEBUG
endif
ifeq ($(CONAN_TC_SET_LIBCXX),True)
CONAN_TC_CLANG_BASED := $(if $(filter $(CONAN_TC_COMPILER),clang apple-clang),true)
ifeq ($(CONAN_TC_CLANG_BASED),True)
CONAN_TC_LIBSTDCXX_BASED := $(if $(filter $(CONAN_TC_LIBCXX),libstdc++ libstdc++11),true)
ifeq ($(CONAN_TC_LIBSTDCXX_BASED),True)
CONAN_TC_CXXFLAGS += -stdlib=libstdc++
else ifeq ($(CONAN_TC_LIBCXX),libc++)
CONAN_TC_CXXFLAGS += -stdlib=libc++
endif
else ifeq ($(CONAN_TC_COMPILER),sun-cc)
ifeq ($(CONAN_TC_LIBCXX),libCstd)
CONAN_TC_CXXFLAGS += -library=Cstd++
else ifeq ($(CONAN_TC_LIBCXX),libstdcxx)
CONAN_TC_CXXFLAGS += -library=stdcxx4
else ifeq ($(CONAN_TC_LIBCXX),libstlport)
CONAN_TC_CXXFLAGS += -library=stlport4
else ifeq ($(CONAN_TC_LIBCXX),libstdc++)
CONAN_TC_CXXFLAGS += -library=stdcpp
endif
endif
ifeq ($(CONAN_TC_LIBCXX),libstdc++11)
CONAN_TC_DEFINES += GLIBCXX_USE_CXX11_ABI=1
else ifeq ($(CONAN_TC_LIBCXX),libstdc++)
CONAN_TC_DEFINES += GLIBCXX_USE_CXX11_ABI=0
endif
endif
ifeq ($(CONAN_TC_SET_CPPSTD),True)
CONAN_TC_CXXFLAGS += $(CONAN_TC_CPPSTD_FLAG)
endif
ifeq ($(CONAN_TC_SET_ARCH),True)
CONAN_TC_CFLAGS += $(CONAN_TC_ARCH_FLAG)
CONAN_TC_CXXFLAGS += $(CONAN_TC_ARCH_FLAG)
CONAN_TC_SHARED_LINKER_FLAGS += $(CONAN_TC_ARCH_FLAG)
CONAN_TC_EXE_LINKER_FLAGS += $(CONAN_TC_ARCH_FLAG)
endif
ifeq ($(CONAN_TC_SET_FPIC),True)
CONAN_TC_CFLAGS += -fPIC
CONAN_TC_CXXFLAGS += -fPIC
CONAN_TC_SHARED_LINKER_FLAGS += -fPIC
CONAN_TC_EXE_LINKER_FLAGS += -pie
endif
ifeq ($(CONAN_TC_SET_SHARED),True)
CONAN_TC_LDFLAGS += -shared
CONAN_TC_LDFLAGS += $(CONAN_TC_SHARED_LINKER_FLAGS)
else
CONAN_TC_LDFLAGS += $(CONAN_TC_EXE_LINKER_FLAGS)
endif
endif
CONAN_TC_CPPFLAGS += $(addprefix -D,$(CONAN_TC_DEFINES))
# Call this function in your Makefile to have Conan variables added to the standard variables
# Example: $(call CONAN_TC_SETUP)
CONAN_TC_SETUP = \\
$(eval CFLAGS += $(CONAN_TC_CFLAGS)) ; \\
$(eval CXXFLAGS += $(CONAN_TC_CXXFLAGS)) ; \\
$(eval CPPFLAGS += $(CONAN_TC_CPPFLAGS)) ; \\
$(eval LDFLAGS += $(CONAN_TC_LDFLAGS)) ;
"""))
context = {
"arch_host": conanfile.settings.get_safe("arch"),
"arch_build": detected_architecture(),
"compiler": conanfile.settings.get_safe("compiler"),
"compiler_version":
conanfile.settings.get_safe("compiler.version"),
"arch_flag": architecture_flag(settings_mock),
"cppstd_flag": cppstd_flag_new(conanfile.settings),
"build_type_flags": " ".join(build_type_flags(conanfile.settings)),
"build_type": build_type,
"libcxx": libcxx,
"set_shared": shared,
"set_fpic": fpic,
"preserved_space": " ",
}
#
expected_content = expected_template.render(context)
self.maxDiff = None
self.assertIn(expected_content, content)
def test_variables_setup(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.defines = ["MYDEFINE1"]
cpp_info.cflags.append("-Flag1=23")
cpp_info.version = "1.3"
cpp_info.description = "My cool description"
cpp_info.libs = ["MyLib1"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.libs = ["MyLib2"]
cpp_info.defines = ["MYDEFINE2"]
cpp_info.version = "2.3"
cpp_info.exelinkflags = ["-exelinkflag"]
cpp_info.sharedlinkflags = ["-sharedlinkflag"]
cpp_info.cxxflags = ["-cxxflag"]
cpp_info.public_deps = ["MyPkg"]
cpp_info.libdirs.extend(["Path\\with\\slashes", "regular/path/to/dir"])
cpp_info.includedirs.extend(
["other\\Path\\with\\slashes", "other/regular/path/to/dir"])
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = BoostBuildGenerator(conanfile)
self.assertEqual(
generator.content, """lib MyLib1 :
: # requirements
<name>MyLib1
: # default-build
: # usage-requirements
<define>MYDEFINE1
<cflags>-Flag1=23
;
lib MyLib2 :
: # requirements
<name>MyLib2
<search>dummy_root_folder2/lib
<search>dummy_root_folder2/Path/with/slashes
<search>dummy_root_folder2/regular/path/to/dir
: # default-build
: # usage-requirements
<define>MYDEFINE2
<include>dummy_root_folder2/include
<include>dummy_root_folder2/other/Path/with/slashes
<include>dummy_root_folder2/other/regular/path/to/dir
<cxxflags>-cxxflag
<ldflags>-sharedlinkflag
;
alias conan-deps :
MyLib1
MyLib2
;
""")
