def test_autotools_namespace():
client = TestClient()
namespace = "somename"
conanfile = textwrap.dedent("""
from conans import ConanFile
from conan.tools.gnu import AutotoolsToolchain, Autotools
class Conan(ConanFile):
settings = "os", "arch", "compiler", "build_type"
def generate(self):
autotools = AutotoolsToolchain(self, namespace='{0}')
autotools.configure_args = ['a', 'b']
autotools.make_args = ['c', 'd']
autotools.generate()
def build(self):
autotools = Autotools(self, namespace='{0}')
self.output.info(autotools._configure_args)
self.output.info(autotools._make_args)
""".format(namespace))
client.save({"conanfile.py": conanfile})
client.run("install .")
assert os.path.isfile(
os.path.join(client.current_folder,
"{}_{}".format(namespace, CONAN_TOOLCHAIN_ARGS_FILE)))
content = load_toolchain_args(generators_folder=client.current_folder,
namespace=namespace)
at_configure_args = content.get("configure_args")
at_make_args = content.get("make_args")
client.run("build .")
assert at_configure_args in client.out
assert at_make_args in client.out
def __init__(self, conanfile, namespace=None):
self._conanfile = conanfile
toolchain_file_content = load_toolchain_args(
self._conanfile.generators_folder, namespace=namespace)
self._configure_args = toolchain_file_content.get("configure_args")
self._make_args = toolchain_file_content.get("make_args")
def test_load_empty_toolchain_args_in_default_dir():
save(CONAN_TOOLCHAIN_ARGS_FILE, "[%s]" % CONAN_TOOLCHAIN_ARGS_SECTION)
try:
config = load_toolchain_args()
assert not config
finally:
remove(CONAN_TOOLCHAIN_ARGS_FILE)
def test_ninja_conf():
conanfile = GenConanfile().with_generator("CMakeToolchain").with_settings("os", "compiler",
"build_type", "arch")
profile = textwrap.dedent("""
[settings]
os=Windows
compiler=msvc
compiler.version=191
compiler.runtime=dynamic
compiler.cppstd=14
build_type=Release
arch=x86_64
[conf]
tools.cmake.cmaketoolchain:generator=Ninja
""")
client = TestClient()
client.save({"conanfile.py": conanfile,
"profile": profile})
client.run("install . -pr=profile")
conanbuild = load_toolchain_args(client.current_folder)
assert conanbuild["cmake_generator"] == "Ninja"
vcvars = client.load("conanvcvars.bat")
assert "2017" in vcvars
# toolchain cannot define the CMAKE_GENERATOR_TOOLSET for Ninja
cmake = client.load("conan_toolchain.cmake")
assert "CMAKE_GENERATOR_TOOLSET" not in cmake
def test_cmake_namespace():
client = TestClient()
namespace = "somename"
conanfile = textwrap.dedent("""
from conans import ConanFile
from conan.tools.cmake import CMakeToolchain, CMake
class Conan(ConanFile):
settings = "os", "arch", "compiler", "build_type"
def generate(self):
cmake = CMakeToolchain(self, namespace='{0}')
cmake.generate()
def build(self):
cmake = CMake(self, namespace='{0}')
self.output.info(cmake._generator)
self.output.info(cmake._toolchain_file)
""".format(namespace))
client.save({"conanfile.py": conanfile})
client.run("install . ")
assert os.path.isfile(
os.path.join(client.current_folder,
"{}_{}".format(namespace, CONAN_TOOLCHAIN_ARGS_FILE)))
content = load_toolchain_args(generators_folder=client.current_folder,
namespace=namespace)
generator = content.get("cmake_generator")
toolchain_file = content.get("cmake_toolchain_file")
client.run("build . ")
assert generator in client.out
assert toolchain_file in client.out
def test_cmake_toolchain_custom_toolchain():
client = TestClient(path_with_spaces=False)
conanfile = GenConanfile().with_settings("os", "compiler", "build_type", "arch").\
with_generator("CMakeToolchain")
save(client.cache.new_config_path, "tools.cmake.cmaketoolchain:toolchain_file=mytoolchain.cmake")
client.save({"conanfile.py": conanfile})
client.run("install .")
assert not os.path.exists(os.path.join(client.current_folder, "conan_toolchain.cmake"))
build_content = load_toolchain_args(client.current_folder)
assert "mytoolchain.cmake" == build_content["cmake_toolchain_file"]
def test_toolchain_empty_config():
client = TestClient(path_with_spaces=False)
conanfile = GenConanfile().with_settings("os", "compiler", "build_type", "arch").\
with_generator("BazelToolchain")
client.save({"conanfile.py": conanfile})
client.run("install .")
config = load_toolchain_args(client.current_folder)
assert not config
def test_toolchain_args_with_content_full():
temp_folder = tempfile.mkdtemp()
content = textwrap.dedent(r"""
[%s]
win_path=my\win\path
command=conan --option "My Option"
my_regex=([A-Z])\w+
""" % CONAN_TOOLCHAIN_ARGS_SECTION)
save(os.path.join(temp_folder, CONAN_TOOLCHAIN_ARGS_FILE), content)
args = load_toolchain_args(generators_folder=temp_folder)
assert args["win_path"] == r'my\win\path'
assert args["command"] == r'conan --option "My Option"'
assert args["my_regex"] == r'([A-Z])\w+'
def __init__(self, conanfile, namespace=None):
_validate_recipe(conanfile)
# Store a reference to useful data
self._conanfile = conanfile
self._namespace = namespace
toolchain_file_content = load_toolchain_args(
self._conanfile.generators_folder, namespace=self._namespace)
self._generator = toolchain_file_content.get("cmake_generator")
self._toolchain_file = toolchain_file_content.get(
"cmake_toolchain_file")
self._cmake_program = "cmake" # Path to CMake should be handled by environment
def test_target_triple():
f = temp_folder()
chdir(f)
conanfile = ConanFileMock()
conanfile.settings = MockSettings({"os": "Linux", "arch": "x86_64"})
conanfile.settings_build = MockSettings({"os": "Solaris", "arch": "x86"})
conanfile.conf = Conf()
conanfile.conf["tools.gnu:make_program"] = "my_make"
conanfile.conf["tools.gnu.make:jobs"] = "23"
be = AutotoolsToolchain(conanfile)
be.make_args = ["foo", "var"]
be.generate_args()
obj = load_toolchain_args()
assert "--host=x86_64-linux-gnu" in obj["configure_args"]
assert "--build=i686-solaris" in obj["configure_args"]
assert obj["make_args"].replace("'", "") == "foo var"
def test_toolchain_loads_config_from_profile():
client = TestClient(path_with_spaces=False)
profile = textwrap.dedent("""
include(default)
[conf]
tools.google.bazel:config=test_config
tools.google.bazel:bazelrc_path=/path/to/bazelrc
""")
conanfile = GenConanfile().with_settings("os", "compiler", "build_type", "arch").\
with_generator("BazelToolchain")
client.save({"conanfile.py": conanfile, "test_profile": profile})
client.run("install . -pr=test_profile")
config = load_toolchain_args(client.current_folder)
assert config['bazel_config'] == "test_config"
assert config['bazelrc_path'] == "/path/to/bazelrc"
def test_bazel_namespace():
client = TestClient()
namespace = "somename"
conanfile = textwrap.dedent("""
from conans import ConanFile
from conan.tools.google import BazelToolchain, Bazel
class Conan(ConanFile):
settings = "os", "arch", "compiler", "build_type"
def generate(self):
bazel = BazelToolchain(self, namespace='{0}')
bazel.generate()
def build(self):
bazel = Bazel(self, namespace='{0}')
self.output.info(bazel._bazel_config)
self.output.info(bazel._bazelrc_path)
""".format(namespace))
profile = textwrap.dedent("""
include(default)
[conf]
tools.google.bazel:config=test_config
tools.google.bazel:bazelrc_path=/path/to/bazelrc
""")
client.save({"test_profile": profile})
client.save({"conanfile.py": conanfile})
client.run("install . -pr test_profile")
assert os.path.isfile(
os.path.join(client.current_folder,
"{}_{}".format(namespace, CONAN_TOOLCHAIN_ARGS_FILE)))
content = load_toolchain_args(generators_folder=client.current_folder,
namespace=namespace)
bazel_config = content.get("bazel_config")
bazelrc_path = content.get("bazelrc_path")
client.run("build .")
assert bazel_config in client.out
assert bazelrc_path in client.out
def test_ios():
xcrun = XCRun(None, sdk='iphoneos')
cflags = ""
cflags += " -isysroot " + xcrun.sdk_path
cflags += " -arch " + to_apple_arch('armv8')
cxxflags = cflags
ldflags = cflags
profile = textwrap.dedent("""
include(default)
[settings]
os=iOS
os.version=12.0
arch=armv8
[env]
CC={cc}
CXX={cxx}
CFLAGS={cflags}
CXXFLAGS={cxxflags}
LDFLAGS={ldflags}
""").format(cc=xcrun.cc,
cxx=xcrun.cxx,
cflags=cflags,
cxxflags=cxxflags,
ldflags=ldflags)
client = TestClient(path_with_spaces=False)
client.save({"m1": profile}, clean_first=True)
client.run("new hello/0.1 --template=cmake_lib")
client.run("create . --profile:build=default --profile:host=m1 -tf None")
main = gen_function_cpp(name="main", includes=["hello"], calls=["hello"])
makefile_am = gen_makefile_am(main="main", main_srcs="main.cpp")
configure_ac = gen_configure_ac()
conanfile = textwrap.dedent("""
from conans import ConanFile
from conan.tools.gnu import Autotools
class TestConan(ConanFile):
requires = "hello/0.1"
settings = "os", "compiler", "arch", "build_type"
exports_sources = "configure.ac", "Makefile.am", "main.cpp"
generators = "AutotoolsToolchain", "AutotoolsDeps"
def build(self):
self.run("aclocal")
self.run("autoconf")
self.run("automake --add-missing --foreign")
autotools = Autotools(self)
autotools.configure()
autotools.make()
""")
client.save(
{
"conanfile.py": conanfile,
"configure.ac": configure_ac,
"Makefile.am": makefile_am,
"main.cpp": main,
"m1": profile
},
clean_first=True)
client.run("install . --profile:build=default --profile:host=m1")
client.run("build .")
client.run_command("./main", assert_error=True)
assert "Bad CPU type in executable" in client.out
client.run_command("lipo -info main")
assert "Non-fat file: main is architecture: arm64" in client.out
conanbuild = load_toolchain_args(client.current_folder)
configure_args = conanbuild["configure_args"]
assert configure_args == "'--host=aarch64-apple-ios' '--build=x86_64-apple-darwin'"
def test_multiple_toolchains_one_recipe():
# https://github.com/conan-io/conan/issues/9376
client = TestClient()
namespaces = ["autotools", "bazel", "cmake"]
conanfile = textwrap.dedent("""
from conans import ConanFile
from conan.tools.gnu import AutotoolsToolchain, Autotools
from conan.tools.google import BazelToolchain, Bazel
from conan.tools.cmake import CMakeToolchain, CMake
class Conan(ConanFile):
settings = "os", "arch", "compiler", "build_type"
def generate(self):
autotools = AutotoolsToolchain(self, namespace='{0}')
autotools.configure_args = ['a', 'b']
autotools.make_args = ['c', 'd']
autotools.generate()
bazel = BazelToolchain(self, namespace='{1}')
bazel.generate()
cmake = CMakeToolchain(self, namespace='{2}')
cmake.generate()
def build(self):
autotools = Autotools(self, namespace='{0}')
self.output.info(autotools._configure_args)
self.output.info(autotools._make_args)
bazel = Bazel(self, namespace='{1}')
self.output.info(bazel._bazel_config)
self.output.info(bazel._bazelrc_path)
cmake = CMake(self, namespace='{2}')
self.output.info(cmake._generator)
self.output.info(cmake._toolchain_file)
""".format(*namespaces))
client.save({"conanfile.py": conanfile})
profile = textwrap.dedent("""
include(default)
[conf]
tools.google.bazel:config=test_config
tools.google.bazel:bazelrc_path=/path/to/bazelrc
""")
client.save({"test_profile": profile})
client.run("install . -pr test_profile")
check_args = {
"autotools": ["configure_args", "make_args"],
"bazel": ["bazel_config", "bazelrc_path"],
"cmake": ["cmake_generator", "cmake_toolchain_file"]
}
checks = []
for namespace in namespaces:
assert os.path.isfile(
os.path.join(client.current_folder,
"{}_{}".format(namespace, CONAN_TOOLCHAIN_ARGS_FILE)))
content = load_toolchain_args(generators_folder=client.current_folder,
namespace=namespace)
for arg in check_args.get(namespace):
checks.append(content.get(arg))
client.run("build .")
for check in checks:
assert check in client.out
def test_load_toolchain_args_if_it_does_not_exist():
with pytest.raises(ConanException):
load_toolchain_args()
def _get_bazel_project_configuration(self):
toolchain_file_content = load_toolchain_args(
self._conanfile.generators_folder)
self._bazel_config = toolchain_file_content.get("bazel_config")
self._bazelrc_path = toolchain_file_content.get("bazelrc_path")
def test_load_toolchain_args_if_it_does_not_exist():
folder = temp_folder()
os.chdir(folder)
with pytest.raises(ConanException):
load_toolchain_args()
