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_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_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_load_empty_toolchain_args_in_default_dir(): folder = temp_folder() os.chdir(folder) 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_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_multiple_toolchains_one_recipe(): # https://github.com/conan-io/conan/issues/9376 client = TestClient() namespaces = ["autotools", "bazel"] conanfile = textwrap.dedent(""" from conans import ConanFile from conan.tools.gnu import AutotoolsToolchain, Autotools from conan.tools.google import BazelToolchain, Bazel 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() 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) """.format(*namespaces)) client.save({"conanfile.py": conanfile}) profile = textwrap.dedent(""" include(default) [conf] tools.google.bazel:configs=["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_configs", "bazelrc_path"], } 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_toolchain_args_with_content_full(): folder = temp_folder() 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(folder, CONAN_TOOLCHAIN_ARGS_FILE), content) args = load_toolchain_args(generators_folder=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:configs=["test_config", "test_config2"] 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_configs'] == "test_config,test_config2" 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 _get_bazel_project_configuration(self): toolchain_file_content = load_toolchain_args(self._conanfile.generators_folder, namespace=self._namespace) configs = toolchain_file_content.get("bazel_configs") self._bazel_config = configs.split(",") if configs else [] 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()
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.sdk=iphoneos 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): autotools = Autotools(self) autotools.autoreconf() 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"] make_args = conanbuild["make_args"] autoreconf_args = conanbuild["autoreconf_args"] assert configure_args == "'--prefix=/' '--bindir=${prefix}/bin' '--sbindir=${prefix}/bin' " \ "'--libdir=${prefix}/lib' '--includedir=${prefix}/include' " \ "'--oldincludedir=${prefix}/include' '--datarootdir=${prefix}/res' " \ "'--host=aarch64-apple-ios' '--build=x86_64-apple-darwin'" assert make_args == "" assert autoreconf_args == "'--force' '--install'"