def setUp(self):
self.output = TestBufferConanOutput()
self.loader = ConanFileLoader(None, Settings.loads(""), Profile())
self.retriever = Retriever(self.loader, self.output)
self.remote_search = MockSearchRemote()
paths = SimplePaths(self.retriever.folder)
self.resolver = RangeResolver(self.output, paths, self.remote_search)
self.builder = DepsGraphBuilder(self.retriever, self.output, self.loader, self.resolver)
for v in ["0.1", "0.2", "0.3", "1.1", "1.1.2", "1.2.1", "2.1", "2.2.1"]:
say_content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "%s"
""" % v
say_ref = ConanFileReference.loads("Say/%s@memsharded/testing" % v)
self.retriever.conan(say_ref, say_content)
def test_package_settings(self):
# CREATE A CONANFILE TO LOAD
tmp_dir = temp_folder()
conanfile_path = os.path.join(tmp_dir, "conanfile.py")
conanfile = """from conans import ConanFile
class MyTest(ConanFile):
requires = {}
name = "MyPackage"
version = "1.0"
settings = "os"
"""
save(conanfile_path, conanfile)
# Apply windows for MyPackage
profile = Profile()
profile.package_settings = {
"MyPackage": OrderedDict([("os", "Windows")])
}
loader = ConanFileLoader(None, Settings({"os": ["Windows", "Linux"]}),
profile)
recipe = loader.load_conan(conanfile_path, None)
self.assertEquals(recipe.settings.os, "Windows")
# Apply Linux for MyPackage
profile.package_settings = {
"MyPackage": OrderedDict([("os", "Linux")])
}
loader = ConanFileLoader(None, Settings({"os": ["Windows", "Linux"]}),
profile)
recipe = loader.load_conan(conanfile_path, None)
self.assertEquals(recipe.settings.os, "Linux")
# If the package name is different from the conanfile one, it wont apply
profile.package_settings = {
"OtherPACKAGE": OrderedDict([("os", "Linux")])
}
loader = ConanFileLoader(None, Settings({"os": ["Windows", "Linux"]}),
profile)
recipe = loader.load_conan(conanfile_path, None)
self.assertIsNone(recipe.settings.os.value)
def inherit_short_paths_test(self):
loader = ConanFileLoader(None, Settings(), Profile())
tmp_dir = temp_folder()
conanfile_path = os.path.join(tmp_dir, "conanfile.py")
conanfile = """from base_recipe import BasePackage
class Pkg(BasePackage):
pass
"""
base_recipe = """from conans import ConanFile
class BasePackage(ConanFile):
short_paths = True
"""
save(conanfile_path, conanfile)
save(os.path.join(tmp_dir, "base_recipe.py"), base_recipe)
conan_file = load_conanfile_class(conanfile_path)
self.assertEqual(conan_file.short_paths, True)
result = loader.load_conan(conanfile_path, output=None, consumer=True)
self.assertEqual(result.short_paths, True)
def initialize_default_profile(self):
if not os.path.exists(self.default_profile_path):
self._output.writeln("Auto detecting your dev setup to initialize the "
"default profile (%s)" % self.default_profile_path,
Color.BRIGHT_YELLOW)
default_settings = detect_defaults_settings(self._output,
profile_path=self.default_profile_path)
self._output.writeln("Default settings", Color.BRIGHT_YELLOW)
self._output.writeln("\n".join(["\t%s=%s" % (k, v) for (k, v) in default_settings]),
Color.BRIGHT_YELLOW)
self._output.writeln("*** You can change them in %s ***" % self.default_profile_path,
Color.BRIGHT_MAGENTA)
self._output.writeln("*** Or override with -s compiler='other' -s ...s***\n\n",
Color.BRIGHT_MAGENTA)
default_profile = Profile()
tmp = OrderedDict(default_settings)
default_profile.update_settings(tmp)
save(self.default_profile_path, default_profile.dumps())
def cmd_profile_create(profile_name, cache_profiles_path, output, detect=False):
profile_path = get_profile_path(profile_name, cache_profiles_path, get_cwd(),
exists=False)
if os.path.exists(profile_path):
raise ConanException("Profile already exists")
profile = Profile()
if detect:
settings = detect_defaults_settings(output)
for name, value in settings:
profile.settings[name] = value
contents = profile.dumps()
save(profile_path, contents)
if detect:
output.info("Profile created with detected settings: %s" % profile_path)
else:
output.info("Empty profile created: %s" % profile_path)
return profile_path
def profile_from_args(profiles, settings, options, env, conf, cwd, cache):
""" Return a Profile object, as the result of merging a potentially existing Profile
file and the args command-line arguments
"""
default_profile = cache.default_profile # Ensures a default profile creating
if profiles is None:
result = default_profile
else:
result = Profile()
for p in profiles:
tmp, _ = read_profile(p, cwd, cache.profiles_path)
result.compose(tmp)
args_profile = _profile_parse_args(settings, options, env, conf)
if result:
result.compose(args_profile)
else:
result = args_profile
return result
def _create_profile(self, name, settings, scopes=None, package_settings=None,
env=None, package_env=None):
package_env = package_env or {}
profile = Profile()
profile._settings = settings or {}
if scopes:
profile.scopes = Scopes.from_list(["%s=%s" % (key, value) for key, value in scopes.items()])
if package_settings:
profile._package_settings = package_settings
for package_name, envs in package_env.items():
for var_name, value in envs:
profile._package_env[package_name][var_name] = value
for var_name, value in env or {}:
profile._env[var_name] = value
save(self.client.client_cache.profile_path(name), profile.dumps())
def _load_profile(text, profile_path, default_folder):
""" Parse and return a Profile object from a text config like representation.
cwd is needed to be able to load the includes
"""
try:
inherited_profile = Profile()
cwd = os.path.dirname(
os.path.abspath(profile_path)) if profile_path else None
profile_parser = ProfileParser(text)
# Iterate the includes and call recursive to get the profile and variables
# from parent profiles
for include in profile_parser.get_includes():
# Recursion !!
profile, included_vars = read_profile(include, cwd, default_folder)
inherited_profile.compose(profile)
profile_parser.update_vars(included_vars)
# Apply the automatic PROFILE_DIR variable
if cwd:
profile_parser.vars["PROFILE_DIR"] = os.path.abspath(cwd).replace(
'\\', '/')
# Replace the variables from parents in the current profile
profile_parser.apply_vars()
# Current profile before update with parents (but parent variables already applied)
doc = ConfigParser(profile_parser.profile_text,
allowed_fields=[
"build_requires", "settings", "env", "options",
"conf", "buildenv"
])
# Merge the inherited profile with the readed from current profile
_apply_inner_profile(doc, inherited_profile)
return inherited_profile, profile_parser.vars
except ConanException:
raise
except Exception as exc:
raise ConanException("Error parsing the profile text file: %s" %
str(exc))
def profile_from_args(profiles,
settings,
options,
env,
conf,
cwd,
cache,
build_profile=False):
""" Return a Profile object, as the result of merging a potentially existing Profile
file and the args command-line arguments
"""
# Ensures a default profile creating
default_profile = cache.default_profile
create_profile = profiles or settings or options or env or conf or not build_profile
if profiles is None:
default_name = "core:default_build_profile" if build_profile else "core:default_profile"
default_conf = cache.new_config[default_name]
if default_conf is not None:
default_profile_path = default_conf if os.path.isabs(default_conf) \
else os.path.join(cache.profiles_path, default_conf)
result, _ = read_profile(default_profile_path, os.getcwd(),
cache.profiles_path)
elif create_profile:
result = default_profile
else:
result = None
else:
result = Profile()
for p in profiles:
tmp, _ = read_profile(p, cwd, cache.profiles_path)
result.compose_profile(tmp)
args_profile = _profile_parse_args(settings, options, env, conf)
if result:
result.compose_profile(args_profile)
else:
if create_profile:
result = args_profile
return result
def build_consumer(self, path, profile_build_requires=None, ref=None, create_ref=None,
install=True):
profile = Profile()
if profile_build_requires:
profile.build_requires = profile_build_requires
profile.process_settings(self.cache)
update = check_updates = False
recorder = ActionRecorder()
remotes = Remotes()
build_mode = [] # Means build all
ref = ref or ConanFileReference(None, None, None, None, validate=False)
options = OptionsValues()
graph_info = GraphInfo(profile, options=options, root_ref=ref)
app = self._get_app()
deps_graph = app.graph_manager.load_graph(path, create_ref, graph_info, build_mode,
check_updates, update, remotes, recorder)
if install:
binary_installer = BinaryInstaller(app, recorder)
build_mode = BuildMode(build_mode, app.out)
binary_installer.install(deps_graph, None, build_mode, update, False, graph_info)
return deps_graph
def build_graph(self, content, profile_build_requires=None, ref=None, create_ref=None):
path = temp_folder()
path = os.path.join(path, "conanfile.py")
save(path, str(content))
self.loader.cached_conanfiles = {}
profile = Profile()
if profile_build_requires:
profile.build_requires = profile_build_requires
profile.process_settings(self.cache)
update = check_updates = False
recorder = ActionRecorder()
remotes = Remotes()
build_mode = []
ref = ref or ConanFileReference(None, None, None, None, validate=False)
options = OptionsValues()
graph_info = GraphInfo(profile, options, root_ref=ref)
deps_graph, _ = self.manager.load_graph(path, create_ref, graph_info,
build_mode, check_updates, update,
remotes, recorder)
self.binary_installer.install(deps_graph, False, graph_info)
return deps_graph
def create_profile(folder, name, settings=None, package_settings=None, env=None,
package_env=None, options=None):
package_env = package_env or {}
profile = Profile()
profile.settings = settings or {}
if package_settings:
profile.package_settings = package_settings
if options:
profile.options = OptionsValues(options)
for package_name, envs in package_env.items():
for var_name, value in envs:
profile.env_values.add(var_name, value, package_name)
for var_name, value in env or {}:
profile.env_values.add(var_name, value)
save(os.path.join(folder, name), profile.dumps())
def profile_dump_order_test(self):
# Settings
profile = Profile()
profile.package_settings["zlib"] = {"compiler": "gcc"}
profile.settings["arch"] = "x86_64"
profile.settings["compiler"] = "Visual Studio"
profile.settings["compiler.version"] = "12"
profile.build_requires["*"] = ["zlib/1.2.8@lasote/testing"]
profile.build_requires["zlib/*"] = [
"aaaa/1.2.3@lasote/testing", "bb/1.2@lasote/testing"
]
self.assertEqual(
"""[settings]
arch=x86_64
compiler=Visual Studio
compiler.version=12
zlib:compiler=gcc
[options]
[build_requires]
*: zlib/1.2.8@lasote/testing
zlib/*: aaaa/1.2.3@lasote/testing, bb/1.2@lasote/testing
[env]""".splitlines(),
profile.dumps().splitlines())
def test_not_crossbuilding(self):
""" Build_requires uses 'force_host_context=False', but no profile for build_machine """
profile_host = Profile()
profile_host.settings["os"] = "Host"
profile_host.process_settings(self.cache)
try:
deps_graph = self._build_graph(profile_host=profile_host, profile_build=None, install=True)
except Exception as e:
self.fail("ERROR! Although the recipe specifies 'force_host_context=False', as we"
" are not providing a profile for the build_machine, the context will be"
" host for this build_require.\n Exception has been: {}".format(e))
else:
# Check packages (all are HOST packages)
application = deps_graph.root.dependencies[0].dst
self.assertEqual(len(application.dependencies), 3)
self.assertEqual(application.conanfile.name, "app")
self.assertEqual(application.context, CONTEXT_HOST)
self.assertEqual(application.conanfile.settings.os, profile_host.settings['os'])
protobuf_host = application.dependencies[0].dst
self.assertEqual(protobuf_host.conanfile.name, "protobuf")
self.assertEqual(protobuf_host.context, CONTEXT_HOST)
self.assertEqual(protobuf_host.conanfile.settings.os, profile_host.settings['os'])
protoc_host = application.dependencies[1].dst
self.assertEqual(protoc_host.conanfile.name, "protoc")
self.assertEqual(protoc_host.context, CONTEXT_HOST)
self.assertEqual(protoc_host.conanfile.settings.os, profile_host.settings['os'])
protoc_protobuf_host = protoc_host.dependencies[0].dst
self.assertEqual(protoc_protobuf_host, protobuf_host)
gtest_host = application.dependencies[2].dst
self.assertEqual(gtest_host.conanfile.name, "gtest")
self.assertEqual(gtest_host.context, CONTEXT_HOST)
self.assertEqual(gtest_host.conanfile.settings.os, profile_host.settings['os'])
def load_imports_arguments_test(self):
file_content = '''
[imports]
OpenCV/bin, * -> ./bin # I need this binaries
OpenCV/lib, * -> ./lib @ root_package=Pkg
OpenCV/data, * -> ./data @ root_package=Pkg, folder=True # Irrelevant
docs, * -> ./docs @ root_package=Pkg, folder=True, ignore_case=True, excludes="a b c" # Other
'''
tmp_dir = temp_folder()
file_path = os.path.join(tmp_dir, "file.txt")
save(file_path, file_content)
loader = ConanFileLoader(None, Settings(), Profile())
ret = loader.load_conan_txt(file_path, None)
ret.copy = Mock()
ret.imports()
expected = [
call(u'*', u'./bin', u'OpenCV/bin', None, False, False, None),
call(u'*', u'./lib', u'OpenCV/lib', u'Pkg', False, False, None),
call(u'*', u'./data', u'OpenCV/data', u'Pkg', True, False, None),
call(u'*', u'./docs', u'docs', u'Pkg', True, True,
[u'"a', u'b', u'c"'])
]
self.assertEqual(ret.copy.call_args_list, expected)
def complete_test(self):
""" basic installation of a new conans
"""
client = TestClient()
client.init_dynamic_vars()
files = hello_source_files()
conan_ref = ConanFileReference.loads("Hello/1.2.1/frodo/stable")
reg_folder = client.paths.export(conan_ref)
client.save(files, path=reg_folder)
client.save(
{
CONANFILE: myconan1,
CONANINFO: "//empty",
"include/no_copy/lib0.h": "NO copy",
"include/math/lib1.h": "copy",
"include/math/lib2.h": "copy",
"include/physics/lib.hpp": "copy",
"my_lib/debug/libd.a": "copy",
"my_data/readme.txt": "copy",
"my_data/readme.md": "NO copy",
"contrib/math/math.h": "copy",
"contrib/physics/gravity.h": "copy",
"contrib/contrib.h": "copy",
"include/opencv/opencv.hpp": "copy",
"include/opencv2/opencv2.hpp": "copy",
"modules/simu/src/simu.cpp": "NO copy",
"modules/simu/include/opencv2/simu/simu.hpp": "copy",
"modules/3D/doc/readme.md": "NO copy",
"modules/3D/include/opencv2/3D/3D.hpp": "copy",
"modules/dev/src/dev.cpp": "NO copy",
"modules/dev/include/opencv2/dev/dev.hpp": "copy",
"modules/opencv_mod.hpp": "copy"
},
path=reg_folder)
conanfile_path = os.path.join(reg_folder, CONANFILE)
package_ref = PackageReference(conan_ref, "myfakeid")
build_folder = client.paths.build(package_ref)
package_folder = client.paths.package(package_ref)
shutil.copytree(reg_folder, build_folder)
output = ScopedOutput("", TestBufferConanOutput())
loader = ConanFileLoader(None, Settings(), Profile())
conanfile = loader.load_conan(conanfile_path, None)
create_package(conanfile,
build_folder,
build_folder,
package_folder,
output,
copy_info=True)
# test build folder
self.assertTrue(os.path.exists(build_folder))
self.assertTrue(os.path.exists(os.path.join(package_folder,
CONANINFO)))
# test pack folder
self.assertTrue(os.path.exists(package_folder))
def exist(rel_path):
return os.path.exists(os.path.join(package_folder, rel_path))
# Expected files
self.assertTrue(exist("include/lib1.h"))
self.assertTrue(exist("include/lib2.h"))
self.assertTrue(exist("include/physics/lib.hpp"))
self.assertTrue(exist("include/contrib/math/math.h"))
self.assertTrue(exist("include/contrib/physics/gravity.h"))
self.assertTrue(exist("include/contrib/contrib.h"))
self.assertTrue(exist("include/opencv/opencv.hpp"))
self.assertTrue(exist("include/opencv2/opencv2.hpp"))
self.assertTrue(exist("include/opencv2/simu/simu.hpp"))
self.assertTrue(exist("include/opencv2/3D/3D.hpp"))
self.assertTrue(exist("include/opencv2/dev/dev.hpp"))
self.assertTrue(exist("lib/my_lib/libd.a"))
self.assertTrue(exist("res/shares/readme.txt"))
# Not expected files
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/opencv2/simu.hpp"))
self.assertFalse(exist("include/opencv2/3D.hpp"))
self.assertFalse(exist("include/opencv2/dev.hpp"))
self.assertFalse(exist("include/modules/simu/src/simu.cpp"))
self.assertFalse(exist("include/modules/3D/doc/readme.md"))
self.assertFalse(exist("include/modules/dev/src/dev.cpp"))
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/include/no_copy/lib0.h"))
self.assertFalse(exist("res/my_data/readme.md"))
def test_crossbuilding(self):
profile_host = Profile()
profile_host.settings["os"] = "Host"
profile_host.process_settings(self.cache)
profile_build = Profile()
profile_build.settings["os"] = "Build"
profile_build.process_settings(self.cache)
deps_graph = self._build_graph(profile_host=profile_host,
profile_build=profile_build,
install=True)
# Check HOST packages
# - app
app = deps_graph.root.dependencies[0].dst
self.assertEqual(len(app.dependencies), 2)
self.assertEqual(app.conanfile.name, "app")
self.assertEqual(app.context, CONTEXT_HOST)
self.assertEqual(app.conanfile.settings.os,
profile_host.settings['os'])
# - app::deps_cpp_info
protobuf_host_cpp_info = app.conanfile.deps_cpp_info["protobuf"]
self.assertEqual(protobuf_host_cpp_info.includedirs, ['protobuf-host'])
self.assertEqual(protobuf_host_cpp_info.libdirs, ['protobuf-host'])
self.assertEqual(protobuf_host_cpp_info.bindirs, ['protobuf-host'])
protobuf_host_cpp_info = app.conanfile.deps_cpp_info["zlib"]
self.assertEqual(protobuf_host_cpp_info.libs, ['zlib-host-1.0'])
self.assertListEqual(list(app.conanfile.deps_cpp_info.libs),
['protobuf-host', 'zlib-host-1.0'])
# - app::deps_env_info
protobuf_env_info = app.conanfile.deps_env_info["protobuf"]
self.assertEqual(protobuf_env_info.PATH, ['protobuf-build'])
self.assertEqual(protobuf_env_info.OTHERVAR, 'protobuf-build')
zlib_env_info = app.conanfile.deps_env_info["zlib"]
self.assertEqual(zlib_env_info.vars["PATH"], ['zlib-build-2.0'])
self.assertEqual(app.conanfile.deps_env_info.vars["PATH"],
['protobuf-build', 'zlib-build-2.0'])
# - protobuf
protobuf_host = app.dependencies[0].dst
self.assertEqual(protobuf_host.conanfile.name, "protobuf")
self.assertEqual(protobuf_host.context, CONTEXT_HOST)
self.assertEqual(protobuf_host.conanfile.settings.os,
profile_host.settings['os'])
# - protobuf::deps_cpp_info
zlib_cpp_info = protobuf_host.conanfile.deps_cpp_info["zlib"]
self.assertEqual(zlib_cpp_info.libs, ['zlib-host-1.0'])
# - protobuf::deps_env_info (no zlib)
zlib_env_info = list(protobuf_host.conanfile.deps_env_info.deps)
self.assertEqual(zlib_env_info, [])
# Check BUILD packages
# - protobuf
protobuf_build = app.dependencies[1].dst
self.assertEqual(protobuf_build.conanfile.name, "protobuf")
self.assertEqual(protobuf_build.context, CONTEXT_BUILD)
self.assertEqual(protobuf_build.conanfile.settings.os,
profile_build.settings['os'])
# - protobuf::deps_cpp_info
zlib_cpp_info = protobuf_build.conanfile.deps_cpp_info["zlib"]
self.assertEqual(zlib_cpp_info.libs, ['zlib-build-2.0'])
# - protobuf::deps_env_info (no zlib)
zlib_env_info = list(protobuf_build.conanfile.deps_env_info.deps)
self.assertEqual(zlib_env_info, [])
def create_profile(profile=None, settings=None):
if profile is None:
profile = Profile()
if profile.processed_settings is None:
profile.processed_settings = settings or Settings()
return profile
def load_conan_txt_test(self):
file_content = '''[requires]
OpenCV/2.4.10@phil/stable
OpenCV2/2.4.10@phil/stable
[build_requires]
MyPkg/1.0.0@phil/stable
[generators]
one
two
[imports]
OpenCV/bin, * -> ./bin # I need this binaries
OpenCV/lib, * -> ./lib
[options]
OpenCV:use_python=True
OpenCV:other_option=False
OpenCV2:use_python2=1
OpenCV2:other_option=Cosa
'''
tmp_dir = temp_folder()
file_path = os.path.join(tmp_dir, "file.txt")
save(file_path, file_content)
loader = ConanFileLoader(None, Settings(), Profile())
ret = loader.load_conan_txt(file_path, None)
options1 = OptionsValues.loads("""OpenCV:use_python=True
OpenCV:other_option=False
OpenCV2:use_python2=1
OpenCV2:other_option=Cosa""")
requirements = Requirements()
requirements.add("OpenCV/2.4.10@phil/stable")
requirements.add("OpenCV2/2.4.10@phil/stable")
build_requirements = []
build_requirements.append("MyPkg/1.0.0@phil/stable")
self.assertEquals(ret.requires, requirements)
self.assertEquals(ret.build_requires, build_requirements)
self.assertEquals(ret.generators, ["one", "two"])
self.assertEquals(ret.options.values.dumps(), options1.dumps())
ret.copy = Mock()
ret.imports()
self.assertTrue(ret.copy.call_args_list,
[('*', './bin', 'OpenCV/bin'),
('*', './lib', 'OpenCV/lib')])
# Now something that fails
file_content = '''[requires]
OpenCV/2.4.104phil/stable
'''
tmp_dir = temp_folder()
file_path = os.path.join(tmp_dir, "file.txt")
save(file_path, file_content)
loader = ConanFileLoader(None, Settings(), Profile())
with self.assertRaisesRegexp(ConanException,
"Wrong package recipe reference(.*)"):
loader.load_conan_txt(file_path, None)
file_content = '''[requires]
OpenCV/2.4.10@phil/stable111111111111111111111111111111111111111111111111111111111111111
[imports]
OpenCV/bin/* - ./bin
'''
tmp_dir = temp_folder()
file_path = os.path.join(tmp_dir, "file.txt")
save(file_path, file_content)
loader = ConanFileLoader(None, Settings(), Profile())
with self.assertRaisesRegexp(ConanException,
"is too long. Valid names must contain"):
loader.load_conan_txt(file_path, None)
def test_crossbuilding(self):
profile_host = Profile()
profile_host.settings["os"] = "Host"
profile_host.process_settings(self.cache)
profile_build = Profile()
profile_build.settings["os"] = "Build"
profile_build.process_settings(self.cache)
deps_graph = self._build_graph(profile_host=profile_host,
profile_build=profile_build,
install=True)
# Check HOST packages
# - Application
application = deps_graph.root.dependencies[0].dst
self.assertEqual(len(application.dependencies), 3)
self.assertEqual(application.conanfile.name, "app")
self.assertEqual(application.context, CONTEXT_HOST)
self.assertEqual(application.conanfile.settings.os,
profile_host.settings['os'])
# - Application::deps_cpp_info:
gtest_cpp_info = application.conanfile.deps_cpp_info["gtest"]
self.assertEqual(gtest_cpp_info.includedirs, ['gtest-host'])
self.assertEqual(gtest_cpp_info.libdirs, ['gtest-host'])
self.assertEqual(gtest_cpp_info.bindirs, ['gtest-host'])
with self.assertRaises(KeyError):
_ = application.conanfile.deps_cpp_info["cmake"]
with self.assertRaises(KeyError):
_ = application.conanfile.deps_cpp_info["protoc"]
# - Application::deps_env_info:
cmake_env_info = application.conanfile.deps_env_info["cmake"]
self.assertEqual(cmake_env_info.PATH, ['cmake-build'])
self.assertEqual(cmake_env_info.OTHERVAR, 'cmake-build')
protoc_env_info = application.conanfile.deps_env_info["protoc"]
self.assertEqual(protoc_env_info.PATH, ['protoc-build'])
self.assertEqual(protoc_env_info.OTHERVAR, 'protoc-build')
with self.assertRaises(KeyError):
_ = application.conanfile.deps_env_info["gtest"]
# - GTest
gtest_host = application.dependencies[1].dst
self.assertEqual(gtest_host.conanfile.name, "gtest")
self.assertEqual(gtest_host.context, CONTEXT_HOST)
self.assertEqual(gtest_host.conanfile.settings.os,
profile_host.settings['os'])
# - GTest::deps_cpp_info:
with self.assertRaises(KeyError):
_ = gtest_host.conanfile.deps_cpp_info["cmake"]
# - GTest::deps_env_info:
cmake_env_info = gtest_host.conanfile.deps_env_info["cmake"]
self.assertEqual(cmake_env_info.PATH, ['cmake-build'])
self.assertEqual(cmake_env_info.OTHERVAR, 'cmake-build')
# Check BUILD packages
# - CMake
cmake_build = application.dependencies[0].dst
self.assertEqual(cmake_build.conanfile.name, "cmake")
self.assertEqual(cmake_build.context, CONTEXT_BUILD)
self.assertEqual(str(cmake_build.conanfile.settings.os),
profile_build.settings['os'])
# - Protoc
protoc_build = application.dependencies[2].dst
self.assertEqual(protoc_build.conanfile.name, "protoc")
self.assertEqual(protoc_build.context, CONTEXT_BUILD)
self.assertEqual(str(protoc_build.conanfile.settings.os),
profile_build.settings['os'])
# - Protoc::deps_cpp_info:
with self.assertRaises(KeyError):
_ = protoc_build.conanfile.deps_cpp_info["cmake"]
# - Protoc::deps_env_info:
cmake_env_info = protoc_build.conanfile.deps_env_info["cmake"]
self.assertEqual(cmake_env_info.PATH, ['cmake-build'])
self.assertEqual(cmake_env_info.OTHERVAR, 'cmake-build')
# - CMake <- Protoc
cmake_protoc_build = protoc_build.dependencies[1].dst
self.assertNotEqual(cmake_build, cmake_protoc_build)
self.assertEqual(cmake_protoc_build.conanfile.name, "cmake")
self.assertEqual(cmake_protoc_build.context, CONTEXT_BUILD)
self.assertEqual(str(cmake_protoc_build.conanfile.settings.os),
profile_build.settings['os'])
# - CMake <- GTest
cmake_gtest_build = gtest_host.dependencies[0].dst
self.assertNotEqual(cmake_build, cmake_gtest_build)
self.assertEqual(cmake_gtest_build.conanfile.name, "cmake")
self.assertEqual(cmake_gtest_build.context, CONTEXT_BUILD)
self.assertEqual(str(cmake_gtest_build.conanfile.settings.os),
profile_build.settings['os'])
def test_profile_access(self):
profile_host = Profile()
profile_host.settings["os"] = "Host"
profile_host.process_settings(self.cache)
profile_build = Profile()
profile_build.settings["os"] = "Build"
profile_build.process_settings(self.cache)
deps_graph = self._build_graph(profile_host=profile_host,
profile_build=profile_build,
install=True)
# - Application
application = deps_graph.root.dependencies[0].dst
self.assertEqual(application.conanfile.name, "app")
self.assertEqual(application.context, CONTEXT_HOST)
self.assertEqual(application.conanfile.settings.os, "Host")
self.assertEqual(application.conanfile.settings_build.os, "Build")
self.assertEqual(application.conanfile.settings_target, None)
# - protoc
protoc = application.dependencies[0].dst
self.assertEqual(protoc.conanfile.name, "protoc")
self.assertEqual(protoc.context, CONTEXT_BUILD)
self.assertEqual(protoc.conanfile.settings.os, "Build")
self.assertEqual(protoc.conanfile.settings_build.os, "Build")
self.assertEqual(protoc.conanfile.settings_target.os, "Host")
# - protoc/protobuf
protobuf = protoc.dependencies[0].dst
self.assertEqual(protobuf.conanfile.name, "protobuf")
self.assertEqual(protobuf.context, CONTEXT_BUILD)
self.assertEqual(protobuf.conanfile.settings.os, "Build")
self.assertEqual(protobuf.conanfile.settings_build.os, "Build")
self.assertEqual(protobuf.conanfile.settings_target.os, "Host")
# - protoc/cmake
cmake = protoc.dependencies[1].dst
self.assertEqual(cmake.conanfile.name, "cmake")
self.assertEqual(cmake.context, CONTEXT_BUILD)
self.assertEqual(cmake.conanfile.settings.os, "Build")
self.assertEqual(cmake.conanfile.settings_build.os, "Build")
self.assertEqual(cmake.conanfile.settings_target.os, "Build")
# - protoc/gtest
protoc_gtest = protoc.dependencies[2].dst
self.assertEqual(protoc_gtest.conanfile.name, "gtest")
self.assertEqual(protoc_gtest.context, CONTEXT_BUILD)
self.assertEqual(protoc_gtest.conanfile.settings.os, "Build")
self.assertEqual(protoc_gtest.conanfile.settings_build.os, "Build")
# We can't think about an scenario where a `build_require-host` should know about
# the target context. We are removing this information on purpose.
self.assertEqual(protoc_gtest.conanfile.settings_target, None)
# - gtest
gtest = application.dependencies[1].dst
self.assertEqual(gtest.conanfile.name, "gtest")
self.assertEqual(gtest.context, CONTEXT_HOST)
self.assertEqual(gtest.conanfile.settings.os, "Host")
self.assertEqual(gtest.conanfile.settings_build.os, "Build")
self.assertEqual(gtest.conanfile.settings_target, None)
def test_crossbuilding(self):
profile_host = Profile()
profile_host.settings["os"] = "Host"
profile_host.process_settings(self.cache)
profile_build = Profile()
profile_build.settings["os"] = "Build"
profile_build.process_settings(self.cache)
deps_graph = self._build_graph(profile_host=profile_host,
profile_build=profile_build,
install=True)
# Check HOST packages
# - Application
application = deps_graph.root.dependencies[0].dst
self.assertEqual(len(application.dependencies), 4)
self.assertEqual(application.conanfile.name, "app")
self.assertEqual(application.context, CONTEXT_HOST)
self.assertEqual(application.conanfile.settings.os,
profile_host.settings['os'])
# - Application::deps_cpp_info:
protobuf_cpp_info = application.conanfile.deps_cpp_info["protobuf"]
self.assertEqual(protobuf_cpp_info.includedirs, ['protobuf-host'])
self.assertEqual(protobuf_cpp_info.libdirs, ['protobuf-host'])
self.assertEqual(protobuf_cpp_info.bindirs, ['protobuf-host'])
protoc_cpp_info = application.conanfile.deps_cpp_info["protoc"]
self.assertEqual(protoc_cpp_info.includedirs, ['protoc-host'])
self.assertEqual(protoc_cpp_info.libdirs, ['protoc-host'])
self.assertEqual(protoc_cpp_info.bindirs, ['protoc-host'])
gtest_cpp_info = application.conanfile.deps_cpp_info["gtest"]
self.assertEqual(gtest_cpp_info.includedirs, ['gtest-host'])
self.assertEqual(gtest_cpp_info.libdirs, ['gtest-host'])
self.assertEqual(gtest_cpp_info.bindirs, ['gtest-host'])
# - Application::deps_env_info:
protoc_env_info = application.conanfile.deps_env_info["protoc"]
self.assertEqual(protoc_env_info.PATH, ['protoc-build'])
self.assertEqual(protoc_env_info.OTHERVAR, 'protoc-build')
protobuf_env_info = application.conanfile.deps_env_info["protobuf"]
self.assertEqual(protobuf_env_info.PATH, ['protobuf-build'])
self.assertEqual(protobuf_env_info.OTHERVAR, 'protobuf-build')
with self.assertRaises(KeyError):
_ = application.conanfile.deps_env_info["gtest"]
# - Protobuf
protobuf_host = application.dependencies[0].dst
self.assertEqual(protobuf_host.conanfile.name, "protobuf")
self.assertEqual(protobuf_host.context, CONTEXT_HOST)
self.assertEqual(protobuf_host.conanfile.settings.os,
profile_host.settings['os'])
# - Protoc
protoc_host = application.dependencies[2].dst
self.assertEqual(protoc_host.conanfile.name, "protoc")
self.assertEqual(protoc_host.context, CONTEXT_HOST)
self.assertEqual(protoc_host.conanfile.settings.os,
profile_host.settings['os'])
# - Protobuf <- Protoc
protoc_protobuf_host = protoc_host.dependencies[0].dst
self.assertEqual(protoc_protobuf_host, protobuf_host)
# - GTest
gtest_host = application.dependencies[3].dst
self.assertEqual(gtest_host.conanfile.name, "gtest")
self.assertEqual(gtest_host.context, CONTEXT_HOST)
self.assertEqual(gtest_host.conanfile.settings.os,
profile_host.settings['os'])
# Check BUILD packages (default behavior changes if we use profile_build)
# - Protoc
protoc_build = application.dependencies[1].dst
self.assertEqual(protoc_build.conanfile.name, "protoc")
self.assertEqual(protoc_build.context, CONTEXT_BUILD)
self.assertEqual(str(protoc_build.conanfile.settings.os),
profile_build.settings['os'])
# - Protobuf
protobuf_build = protoc_build.dependencies[0].dst
self.assertEqual(protobuf_build.conanfile.name, "protobuf")
self.assertEqual(protoc_build.context, CONTEXT_BUILD)
self.assertEqual(str(protobuf_build.conanfile.settings.os),
profile_build.settings['os'])
def test_crossbuilding(self):
profile_host = Profile()
profile_host.settings["os"] = "Host"
profile_host.process_settings(self.cache)
profile_build = Profile()
profile_build.settings["os"] = "Build"
profile_build.process_settings(self.cache)
deps_graph = self._build_graph(profile_host=profile_host,
profile_build=profile_build,
install=True)
# Check HOST packages
# - Application
application = deps_graph.root.dependencies[0].dst
self.assertEqual(len(application.dependencies), 1)
self.assertEqual(application.conanfile.name, "app")
self.assertEqual(application.context, CONTEXT_HOST)
self.assertEqual(application.conanfile.settings.os,
profile_host.settings['os'])
# - Application::deps_cpp_info:
with self.assertRaises(KeyError):
_ = application.conanfile.deps_cpp_info["host_tool"]
with self.assertRaises(KeyError):
_ = application.conanfile.deps_cpp_info["build_tool"]
# - Application::deps_env_info:
with self.assertRaises(KeyError):
_ = application.conanfile.deps_env_info["host_tool"]
build_tool_env_info = application.conanfile.deps_env_info["build_tool"]
self.assertEqual(build_tool_env_info.PATH, ['build_tool-build'])
self.assertEqual(build_tool_env_info.OTHERVAR, 'build_tool-build')
# Check BUILD package
# - BuildTool
build_tool = application.dependencies[0].dst
self.assertEqual(build_tool.conanfile.name, "build_tool")
self.assertEqual(build_tool.context, CONTEXT_BUILD)
self.assertEqual(build_tool.conanfile.settings.os,
profile_build.settings['os'])
# - BuildTool::deps_cpp_info:
host_tool_cpp_info = build_tool.conanfile.deps_cpp_info["host_tool"]
self.assertEqual(host_tool_cpp_info.includedirs,
['host_tool-build-testing'])
self.assertEqual(host_tool_cpp_info.libdirs,
['host_tool-build-testing'])
self.assertEqual(host_tool_cpp_info.bindirs,
['host_tool-build-testing'])
# - BuildTool::deps_env_info
with self.assertRaises(KeyError):
_ = build_tool.conanfile.deps_env_info["host_tool"]
# - HostTool
# There is no way back to host profile from build one (host===build)
host_tool = build_tool.dependencies[0].dst
self.assertEqual(host_tool.conanfile.name, "host_tool")
self.assertEqual(host_tool.context, CONTEXT_BUILD)
self.assertEqual(str(host_tool.conanfile.settings.os),
profile_build.settings['os'])
def test_processed_profile(profile=None, settings=None):
if profile is None:
profile = Profile()
if profile.processed_settings is None:
profile.processed_settings = settings or Settings()
return ProcessedProfile(profile=profile)
