def test_do_not_mix_cflags_cxxflags(): # TODO: Verify with components too client = TestClient() cpp_info = {"cflags": ["one", "two"], "cxxflags": ["three", "four"]} client.save({"conanfile.py": GenConanfile("upstream", "1.0").with_package_info(cpp_info=cpp_info, env_info={})}) client.run("create .") consumer_conanfile = textwrap.dedent(""" from conans import ConanFile from conan.tools.cmake import CMake class Consumer(ConanFile): name = "consumer" version = "1.0" settings = "os", "compiler", "arch", "build_type" exports_sources = "CMakeLists.txt" requires = "upstream/1.0" generators = "CMakeDeps", "CMakeToolchain" def build(self): cmake = CMake(self) cmake.configure() """) cmakelists = textwrap.dedent(""" cmake_minimum_required(VERSION 3.15) project(consumer NONE) find_package(upstream CONFIG REQUIRED) get_target_property(tmp upstream::upstream INTERFACE_COMPILE_OPTIONS) message("compile options: ${tmp}") message("cflags: ${upstream_COMPILE_OPTIONS_C_RELEASE}") message("cxxflags: ${upstream_COMPILE_OPTIONS_CXX_RELEASE}") """) client.save({"conanfile.py": consumer_conanfile, "CMakeLists.txt": cmakelists}, clean_first=True) client.run("create .") assert "compile options: $<$<CONFIG:Release>:" \ "$<$<COMPILE_LANGUAGE:CXX>:three;four>;$<$<COMPILE_LANGUAGE:C>:one;two>>" in client.out assert "cflags: one;two" in client.out assert "cxxflags: three;four" in client.out
def test_auto_package_only_one_destination(): """If the layout declares more than one destination folder it fails, because it cannot guess where to put the artifacts (very weird situation a package with two include/)""" client = TestClient() conan_file = str(GenConanfile().with_settings("build_type").with_import( "from conans import tools").with_import("import os").with_import( "from conan.tools.layout import LayoutPackager")) conan_file += """ def source(self): tools.save("myincludes/mylib.header","") def build(self): tools.save("ugly_build/mylib.a", "") def layout(self): self.cpp.source.includedirs = ["myincludes"] self.cpp.build.libdirs = ["ugly_build"] self.cpp.build.bindirs = ["ugly_build"] self.cpp.build.frameworkdirs = ["ugly_build"] self.cpp.build.srcdirs = ["ugly_build"] self.cpp.build.builddirs = ["ugly_build"] self.cpp.build.resdirs = ["ugly_build"] self.patterns.source.include = ["*.header"] self.patterns.build.lib = ["*.a"] self.cpp.package.{} = ["folder1", "folder2"] def package(self): LayoutPackager(self).package() """ for dirs in [ "includedirs", "builddirs", "bindirs", "srcdirs", "frameworkdirs", "libdirs", "resdirs" ]: client.save({"conanfile.py": conan_file.format(dirs)}) client.run("create . lib/1.0@", assert_error=True) assert "The package has more than 1 cpp_info.{}, " \ "cannot package automatically".format(dirs) in client.out
def test_build_policies_in_conanfile(self): client = TestClient(default_server_user=True) base = GenConanfile("Hello0", "1.0").with_exports("*") conanfile = str(base) + "\n build_policy = 'missing'" client.save({"conanfile.py": conanfile}) client.run("export . lasote/stable") # Install, it will build automatically if missing (without the --build missing option) client.run("install Hello0/1.0@lasote/stable") self.assertIn("Building", client.out) # Try to do it again, now we have the package, so no build is done client.run("install Hello0/1.0@lasote/stable") self.assertNotIn("Building", client.out) # Try now to upload all packages, should not crash because of the "missing" build policy client.run("upload Hello0/1.0@lasote/stable --all") # --- Build policy to always --- conanfile = str(base) + "\n build_policy = 'always'" client.save({"conanfile.py": conanfile}, clean_first=True) client.run("export . lasote/stable") # Install, it will build automatically if missing (without the --build missing option) client.run("install Hello0/1.0@lasote/stable") self.assertIn( "Detected build_policy 'always', trying to remove source folder", client.out) self.assertIn("Building", client.out) # Try to do it again, now we have the package, but we build again client.run("install Hello0/1.0@lasote/stable") self.assertIn("Building", client.out) self.assertIn( "Detected build_policy 'always', trying to remove source folder", client.out) # Try now to upload all packages, should crash because of the "always" build policy client.run("upload Hello0/1.0@lasote/stable --all", assert_error=True) self.assertIn("no packages can be uploaded", client.out)
def test_local_static_generators_folder(): """If we configure a generators folder in the layout, the generator files: - If belong to new generators: go to the specified folder: "my_generators" - If belong to old generators or txt: remains in the install folder """ client = TestClient() conan_file = str(GenConanfile().with_settings("build_type")) conan_file += """ generators = "cmake", "CMakeToolchain" def layout(self): self.folders.build = "build-{}".format(self.settings.build_type) self.folders.generators = "{}/generators".format(self.folders.build) """ client.save({"conanfile.py": conan_file}) client.run("install . -if=my_install") old_install_folder = os.path.join(client.current_folder, "my_install") conaninfo = os.path.join(old_install_folder, "conaninfo.txt") conanbuildinfo = os.path.join(old_install_folder, "conanbuildinfo.txt") cmake_generator_path = os.path.join(old_install_folder, "conanbuildinfo.cmake") cmake_toolchain_generator_path = os.path.join(old_install_folder, "conan_toolchain.cmake") assert os.path.exists(conaninfo) assert os.path.exists(conanbuildinfo) assert os.path.exists(cmake_generator_path) assert not os.path.exists(cmake_toolchain_generator_path) build_folder = os.path.join(client.current_folder, "build-Release") generators_folder = os.path.join(build_folder, "generators") conaninfo = os.path.join(generators_folder, "conaninfo.txt") conanbuildinfo = os.path.join(generators_folder, "conanbuildinfo.txt") cmake_generator_path = os.path.join(generators_folder, "conanbuildinfo.cmake") cmake_toolchain_generator_path = os.path.join(generators_folder, "conan_toolchain.cmake") assert not os.path.exists(conaninfo) assert not os.path.exists(conanbuildinfo) assert not os.path.exists(cmake_generator_path) assert os.path.exists(cmake_toolchain_generator_path)
def test_install_as_requirement(self): t = self._get_test_client() t.save({'conanfile.py': GenConanfile().with_requires('name/version@user/channel'), 'profile': self.profile}) # Requirement is found t.run('install . consumer/version@ --profile=profile') settings_header = self._get_header(t.api.http_requester, CONAN_REQUEST_HEADER_SETTINGS) self._assert_settings_headers(settings_header) options_headers = self._get_header(t.api.http_requester, CONAN_REQUEST_HEADER_OPTIONS) self._assert_options_headers(options_headers) # Requirement is not found (settings) t.run('install . consumer/version@ --profile=profile -s compiler.version=12.0', assert_error=True) settings_header = self._get_header(t.api.http_requester, CONAN_REQUEST_HEADER_SETTINGS) self._assert_settings_headers(settings_header, compiler_version='12.0') # Requirement is not found (options) t.run('install . consumer/version@ --profile=profile -o name:shared=True', assert_error=True) options_headers = self._get_header(t.api.http_requester, CONAN_REQUEST_HEADER_OPTIONS) self._assert_options_headers(options_headers, shared_value='True')
def test_frameworks_no_compiler(self): client = TestClient() client.save({ "conanfile.py": textwrap.dedent(""" from conans import ConanFile class Pkg(ConanFile): def package_info(self): self.cpp_info.frameworks = ["CoreAudio"] """) }) client.run("export . Hello/0.1@lasote/stable") client.save({ "conanfile.py": GenConanfile().with_requires( "Hello/0.1@lasote/stable").with_generator("xcode") }) client.run('install . --build missing') xcode = client.load(BUILD_INFO_XCODE) self.assertIn('OTHER_LDFLAGS = $(inherited) -framework CoreAudio', xcode)
def test_no_cross_build(): windows_profile = textwrap.dedent(""" [settings] os=Windows arch=x86_64 compiler=gcc compiler.version=6 compiler.libcxx=libstdc++11 build_type=Release """) client = TestClient(path_with_spaces=False) conanfile = GenConanfile().with_settings("os", "arch", "compiler", "build_type")\ .with_generator("CMakeToolchain") client.save({"conanfile.py": conanfile, "windows": windows_profile}) client.run("install . --profile:build=windows --profile:host=windows") toolchain = client.load("conan_toolchain.cmake") assert "CMAKE_SYSTEM_NAME " not in toolchain assert "CMAKE_SYSTEM_PROCESSOR" not in toolchain
def test_info_options(self): # packages with dash client = TestClient() client.save({"conanfile.py": GenConanfile("My-Package", "1.3").with_option("shared", [True, False]) .with_default_option("shared", False)}) # assert they are correct at least client.run("export . myuser/testing") client.run("search") self.assertIn("My-Package/1.3@myuser/testing", client.out) # Check that I can pass options to info client.run("info . -o shared=True") self.assertIn("conanfile.py (My-Package/1.3)", client.out) client.run("info . -o My-Package:shared=True") self.assertIn("conanfile.py (My-Package/1.3)", client.out) # errors client.run("info . -o shared2=True", assert_error=True) self.assertIn("option 'shared2' doesn't exist", client.out) client.run("info . -o My-Package:shared2=True", assert_error=True) self.assertIn("option 'shared2' doesn't exist", client.out)
def test_same_conanfile_local(conanfile): client = TestClient() client.save({"conanfile.py": GenConanfile()}) client.run("create . base/1.0@") client.save({"conanfile.py": conanfile}) source_folder = os.path.join(client.current_folder, "my_sources") build_folder = os.path.join(client.current_folder, "my_build") client.run("install . lib/1.0@ -if=install") client.run("source . -if=install") assert "Source folder: {}".format(source_folder) in client.out assert os.path.exists(os.path.join(source_folder, "source.h")) client.run("build . -if=install") assert "Build folder: {}".format(build_folder) in client.out assert os.path.exists(os.path.join(build_folder, "build.lib")) client.run("package . -if=install", assert_error=True) assert "The usage of the 'conan package' local method is disabled when using " \ "layout()" in client.out
def test_reuse_uploaded_tgz(): client = TestClient(default_server_user=True) # Download packages from a remote, then copy to another channel # and reupload them. Because they have not changed, the tgz is not created again # UPLOAD A PACKAGE ref = ConanFileReference.loads("Hello0/0.1@user/stable") files = { "conanfile.py": GenConanfile("Hello0", "0.1").with_exports("*"), "another_export_file.lib": "to compress" } client.save(files) client.run("create . user/stable") client.run("upload %s --all" % str(ref)) assert "Compressing recipe" in client.out assert "Compressing package" in client.out # UPLOAD TO A DIFFERENT CHANNEL WITHOUT COMPRESS AGAIN client.run("copy %s user/testing --all" % str(ref)) client.run("upload Hello0/0.1@user/testing --all") assert "Compressing recipe" not in client.out assert "Compressing package" not in client.out
def test_token_expired(): server_folder = temp_folder() server_conf = textwrap.dedent(""" [server] jwt_expire_minutes: 0.01 authorize_timeout: 0 disk_authorize_timeout: 0 disk_storage_path: ./data updown_secret: 12345 jwt_secret: mysecret port: 12345 [read_permissions] */*@*/*: * [write_permissions] */*@*/*: admin """) save(os.path.join(server_folder, ".conan_server", "server.conf"), server_conf) server = TestServer(base_path=server_folder, users={"admin": "password"}) c = TestClient(servers={"default": server}, users={"default": [("admin", "password")]}) c.save({"conanfile.py": GenConanfile()}) c.run("create . pkg/0.1@user/stable") c.run("upload * -r=default --all -c") user, token, _ = c.cache.localdb.get_login(server.fake_url) assert user == "admin" assert token is not None import time time.sleep(2) c.users = {} c.run("config set general.non_interactive=1") c.run("remove * -f") c.run("install pkg/0.1@user/stable") user, token, _ = c.cache.localdb.get_login(server.fake_url) assert user == "admin" assert token is None
def setUp(self): self.client = TestClient() conanfile = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" build_policy = "missing" def build(self): self.output.info("Building %s") """ for channel in ("lasote/stable", "other/testing"): self.client.save({"conanfile.py": conanfile % channel}) self.client.run("export . %s" % channel) self.conanfile = """ from conans import ConanFile class HelloConan(ConanFile): name = "Hello" version = "0.1" build_policy = "missing" def requirements(self): self.requires("Say/0.1@%s/%s" % (self.user, self.channel)) def build(self): self.output.info("Building %s/%s" % (self.user, self.channel) ) """ self.test_conanfile = str(GenConanfile().with_require( "Hello/0.1@lasote/stable").with_test("pass")) self.client.save({ "conanfile.py": self.conanfile, "test/conanfile.py": self.test_conanfile })
def test_pkg_with_component_requires(): client = TestClient() client.save({ "conanfile.py": GenConanfile("other", "0.1").with_package_file("file.h", "0.1") }) client.run("create . user/channel") conanfile = textwrap.dedent(""" from conans import ConanFile class PkgConfigConan(ConanFile): requires = "other/0.1@user/channel" def package_info(self): self.cpp_info.components["mycomponent"].requires.append("other::other") self.cpp_info.components["myothercomp"].requires.append("mycomponent") """) client.save({"conanfile.py": conanfile}) client.run("create . pkg/0.1@") client2 = TestClient(cache_folder=client.cache_folder) conanfile = textwrap.dedent(""" [requires] pkg/0.1 [generators] PkgConfigDeps """) client2.save({"conanfile.txt": conanfile}) client2.run("install .") pc_content = client2.load("pkg.pc") assert "Requires: pkg-mycomponent" in pc_content pc_content = client2.load("pkg-mycomponent.pc") assert "Requires: other" in pc_content pc_content = client2.load("pkg-myothercomp.pc") assert "Requires: pkg-mycomponent" in pc_content
def test_scm_with_source_layout(): """If we have the sources in git repository""" conan_file = GenConanfile() \ .with_name("app").with_version("1.0") \ .with_settings("os", "arch", "build_type", "compiler") \ .with_scm({"type": "git", "revision": "auto", "url": "auto"})\ .with_cmake_build() conan_file = str(conan_file) conan_file += """ def layout(self): self.folders.source = "my_src" self.folders.build = "build_{}".format(self.settings.build_type) """ cmake = gen_cmakelists(appname="my_app", appsources=["main.cpp"]) app = gen_function_cpp(name="main") remote_path, _ = create_local_git_repo({"foo": "var"}, branch="my_release") client = TestClient() client.save({ "conanfile.py": conan_file, "my_src/main.cpp": app, "my_src/CMakeLists.txt": cmake, ".gitignore": "build_*\n" }) client.init_git_repo() client.run_command('git remote add origin "%s"' % remote_path.replace("\\", "/")) client.run_command('git push origin master') client.run("install . -if=install") client.run("build . -if=install") assert os.path.exists( os.path.join(client.current_folder, "build_Release", app_name)) client.run("create . ") assert "Created package revision" in client.out
def test_upload_parallel_error(): """Cause an error in the parallel transfer and see some message""" class FailOnReferencesUploader(TestRequester): fail_on = ["lib1", "lib3"] def put(self, *args, **kwargs): if any(ref in args[0] for ref in self.fail_on): raise ConnectionError( "Connection fails with lib2 and lib4 references!") else: return super(FailOnReferencesUploader, self).put(*args, **kwargs) client = TestClient(requester_class=FailOnReferencesUploader, default_server_user=True) client.save({"conanfile.py": GenConanfile()}) client.run('user -p password -r default user') for index in range(4): client.run('create . lib{}/1.0@user/channel'.format(index)) client.run('upload lib* --parallel -c --all -r default --retry-wait=0', assert_error=True) assert "Connection fails with lib2 and lib4 references!" in client.out assert "Execute upload again to retry upload the failed files" in client.out
def test_dirty_download(self): # https://github.com/conan-io/conan/issues/8578 client = TestClient(default_server_user=True) cache_folder = temp_folder() client.run('config set storage.download_cache="%s"' % cache_folder) client.save({ "conanfile.py": GenConanfile().with_package_file("file.txt", "content") }) client.run("create . pkg/0.1@") client.run("upload * --all -c") client.run("remove * -f") client.run("install pkg/0.1@") for f in os.listdir(cache_folder): # damage the file path = os.path.join(cache_folder, f) if os.path.isfile(path): save(path, "broken!") set_dirty(path) client.run("remove * -f") client.run("install pkg/0.1@") assert "pkg/0.1: Downloaded package" in client.out
def test_local_build(): """If we configure a build folder in the layout, the installed files in a "conan build ." go to the specified folder: "my_build" """ client = TestClient() conan_file = str(GenConanfile().with_import("from conans import tools")) conan_file += """ def layout(self): self.folders.generators = "my_generators" self.folders.build = "my_build" def build(self): self.output.warn("Generators folder: {}".format(self.folders.generators_folder)) tools.save("build_file.dll", "bar") """ client.save({"conanfile.py": conan_file}) client.run("install . -if=my_install") # FIXME: This should change to "build ." when "conan build" computes the graph client.run("build . -if=my_install") dll = os.path.join(client.current_folder, "my_build", "build_file.dll") assert os.path.exists(dll)
def test_local_build(): """If we configure a build folder in the layout, the installed files in a "conan build ." go to the specified folder: "my_build" """ # FIXME: The configure is not valid to change the layout, we need the settings and options # ready client = TestClient() conan_file = str(GenConanfile().with_import("from conans import tools")) conan_file += """ def configure(self): self.layout.build.folder = "my_build" def build(self): tools.save("build_file.dll", "bar") """ client.save({"conanfile.py": conan_file}) client.run("install . -if=my_install") # FIXME: This should change to "build ." when "conan build" computes the graph client.run("build . -if=my_install") dll = os.path.join(client.current_folder, "my_build", "build_file.dll") assert os.path.exists(dll)
def _upload_package(self, package_reference, base_files=None): files = { "conanfile.py": GenConanfile("3").with_requires("1", "12").with_exports("*"), "hello.cpp": "hello" } if base_files: files.update(base_files) tmp_dir = temp_folder() abs_paths = {} for filename, content in files.items(): abs_path = os.path.join(tmp_dir, filename) save(abs_path, str(content)) abs_paths[filename] = abs_path self.api.upload_package(package_reference, abs_paths, None, retry=1, retry_wait=0)
def test_install_build_requires(self): # https://github.com/conan-io/conan/issues/8170 client = TestClient() client.save({"conanfile.py": GenConanfile()}) client.run("create . tool/1.0@") conanfile = textwrap.dedent(""" from conans import ConanFile, load class HelloConan(ConanFile): settings = "os", "build_type", "compiler", "arch" build_requires = "tool/1.0" generators = "MSBuildDeps" def build(self): deps = load("conandeps.props") assert "conan_tool.props" not in deps self.output.info("Conan_tools.props not in deps") """) client.save({"conanfile.py": conanfile}) client.run("install .") deps = client.load("conandeps.props") self.assertNotIn("conan_tool.props", deps) client.run("create . pkg/0.1@") self.assertIn("Conan_tools.props not in deps", client.out)
def test_create_test_package_with_layout(conanfile): """The test package using the new generators work (having the generated files in the build folder)""" client = TestClient() conanfile_test = textwrap.dedent(""" import os from conans import ConanFile, tools from conan.tools.cmake import CMakeToolchain, CMake, CMakeDeps class HelloTestConan(ConanFile): settings = "os", "compiler", "build_type", "arch" def generate(self): deps = CMakeDeps(self) deps.generate() tc = CMakeToolchain(self) tc.generate() def layout(self): self.folders.generators = "my_generators" def build(self): assert os.path.exists("my_generators/conan_toolchain.cmake") self.output.warn("hey! building") self.output.warn(os.getcwd()) def test(self): self.output.warn("hey! testing") """) client.save({ "conanfile.py": GenConanfile(), "test_package/conanfile.py": conanfile_test }) client.run("create . lib/1.0@") assert "hey! building" in client.out assert "hey! testing" in client.out
def test_put_properties(self): test_server = TestServer() servers = {"default": test_server} wanted_vars = { "key0": "value", "key1": "with space", "key2": "with/slash", "key3": "with.dot", "key4": "with;semicolon", "key5": "with~virgul", "key6": "with#hash" } class RequesterCheckArtifactProperties(TestRequester): def put(self_requester, url, **kwargs): # Check headers for name, value in wanted_vars.items(): value1 = kwargs["headers"][name] self.assertEqual(value1, value) # Check matrix params self.assertNotIn(';', url) mp = re.match(r"^[^;\s]+;(?P<matrix_params>[^/]+)/.*", url) self.assertFalse(mp) return super(RequesterCheckArtifactProperties, self_requester).put(url, **kwargs) client = TestClient(requester_class=RequesterCheckArtifactProperties, servers=servers, users={"default": [("lasote", "mypass")]}) _create_property_files(client, wanted_vars) client.save({"conanfile.py": GenConanfile("Hello0", "0.1")}) client.run("export . lasote/stable") client.run("upload Hello0/0.1@lasote/stable -c")
def test_extra_flags_via_conf(): os_ = platform.system() os_ = "Macos" if os_ == "Darwin" else os_ profile = textwrap.dedent(""" [settings] os=%s compiler=gcc compiler.version=6 compiler.libcxx=libstdc++11 arch=armv8 build_type=Release [conf] tools.build:cxxflags=["--flag1", "--flag2"] tools.build:cflags+=["--flag3", "--flag4"] tools.build:sharedlinkflags+=["--flag5"] tools.build:exelinkflags+=["--flag6"] tools.build:defines+=["DEF1", "DEF2"] """ % os_) client = TestClient() conanfile = GenConanfile().with_settings("os", "arch", "compiler", "build_type")\ .with_generator("AutotoolsToolchain") client.save({"conanfile.py": conanfile, "profile": profile}) client.run("install . --profile:build=profile --profile:host=profile") toolchain = client.load("conanautotoolstoolchain{}".format('.bat' if os_ == "Windows" else '.sh')) if os_ == "Windows": assert 'set "CPPFLAGS=%CPPFLAGS% -DNDEBUG -DDEF1 -DDEF2"' in toolchain assert 'set "CXXFLAGS=%CXXFLAGS% -O3 -s --flag1 --flag2"' in toolchain assert 'set "CFLAGS=%CFLAGS% -O3 -s --flag3 --flag4"' in toolchain assert 'set "LDFLAGS=%LDFLAGS% --flag5 --flag6"' in toolchain else: assert 'export CPPFLAGS="$CPPFLAGS -DNDEBUG -DDEF1 -DDEF2"' in toolchain assert 'export CXXFLAGS="$CXXFLAGS -O3 -s --flag1 --flag2"' in toolchain assert 'export CFLAGS="$CFLAGS -O3 -s --flag3 --flag4"' in toolchain assert 'export LDFLAGS="$LDFLAGS --flag5 --flag6"' in toolchain
def test_metadata_editable_packages(self): """ Check that 'conan remote' commands work with editable packages """ self.client.save({"conanfile.py": GenConanfile()}) self.client.run("create . pkg/1.1@lasote/stable") self.client.run("upload pkg/1.1@lasote/stable --all -c --remote remote1") self.client.run("remove -f pkg/1.1@lasote/stable") self.client.run("install pkg/1.1@lasote/stable") self.assertIn("pkg/1.1@lasote/stable: Package installed", self.client.out) self.client.run("remote list_ref") self.assertIn("pkg/1.1@lasote/stable: remote1", self.client.out) self.client.run("editable add . pkg/1.1@lasote/stable") # Check add --force, update and rename self.client.run("remote add remote2 %s --force" % self.servers["remote1"].fake_url) self.client.run("remote update remote2 %sfake" % self.servers["remote1"].fake_url) self.client.run("remote rename remote2 remote-fake") self.client.run("editable remove pkg/1.1@lasote/stable") # Check associated remote has changed name self.client.run("remote list_ref") self.assertIn("pkg/1.1@lasote/stable: remote-fake", self.client.out) # Check remove self.client.run("editable add . pkg/1.1@lasote/stable") self.client.run("remote remove remote-fake") self.client.run("remote list") self.assertIn("remote0: %s" % self.servers["remote0"].fake_url, self.client.out) self.assertNotIn("remote-fake", self.client.out) # Check clean self.client.run("editable remove pkg/1.1@lasote/stable") self.client.run("remove -f pkg/1.1@lasote/stable") self.client.run("remote add remote1 %s" % self.servers["remote1"].fake_url) self.client.run("install pkg/1.1@lasote/stable") self.client.run("editable add . pkg/1.1@lasote/stable") self.client.run("remote clean") self.client.run("remote list") self.assertNotIn("remote1", self.client.out) self.assertNotIn("remote0", self.client.out)
def test_cmake_toolchain_win_toolset(compiler, version, update, runtime): client = TestClient(path_with_spaces=False) settings = {"compiler": compiler, "compiler.version": version, "compiler.update": update, "compiler.cppstd": "17", "compiler.runtime": runtime, "build_type": "Release", "arch": "x86_64"} # Build the profile according to the settings provided settings = " ".join('-s %s="%s"' % (k, v) for k, v in settings.items() if v) conanfile = GenConanfile().with_settings("os", "compiler", "build_type", "arch").\ with_generator("CMakeToolchain") client.save({"conanfile.py": conanfile}) client.run("install . {}".format(settings)) toolchain = client.load("conan_toolchain.cmake") if update is not None: # Fullversion value = "version=14.{}{}".format(version[-1], update) else: value = "v14{}".format(version[-1]) assert 'set(CMAKE_GENERATOR_TOOLSET "{}" CACHE STRING "" FORCE)'.format(value) in toolchain
def test_custom_configuration_errors(self): client = TestClient() client.save({"conanfile.py": GenConanfile()}) client.run("create . pkg/1.0@") conanfile = textwrap.dedent(""" from conans import ConanFile from conan.tools.microsoft import MSBuildDeps class Pkg(ConanFile): settings = "os", "compiler", "arch", "build_type" requires = "pkg/1.0" def generate(self): ms = MSBuildDeps(self) ms.configuration = None ms.generate() """) client.save({"conanfile.py": conanfile}) client.run( 'install . -s os=Windows -s compiler="Visual Studio"' ' -s compiler.version={vs_version}' ' -s compiler.runtime=MD'.format(vs_version=self.vs_version), assert_error=True) self.assertIn( "MSBuildDeps.configuration is None, it should have a value", client.out) client.save( {"conanfile.py": conanfile.replace("configuration", "platform")}) client.run( 'install . -s os=Windows -s compiler="Visual Studio"' ' -s compiler.version={vs_version}' ' -s compiler.runtime=MD'.format(vs_version=self.vs_version), assert_error=True) self.assertIn("MSBuildDeps.platform is None, it should have a value", client.out)
def test_same_conanfile_local(conanfile): client = TestClient() client.save({"conanfile.py": GenConanfile()}) client.run("create . base/1.0@") client.save({"conanfile.py": conanfile}) source_folder = os.path.join(client.current_folder, "my_sources") build_folder = os.path.join(client.current_folder, "my_build") client.run("install . lib/1.0@ -if=install") client.run("source . -if=install") assert "Source folder: {}".format(source_folder) in client.out assert os.path.exists(os.path.join(source_folder, "source.h")) client.run("build . -if=install") assert "Build folder: {}".format(build_folder) in client.out assert os.path.exists(os.path.join(build_folder, "build.lib")) client.run("package . -if=install") # By default, the "package" folder is still used (not breaking) pf = os.path.join(client.current_folder, "package") assert "Package folder: {}".format(pf) in client.out assert os.path.exists(os.path.join(pf, "LICENSE"))
def test_frameworks(): client = TestClient(path_with_spaces=False) client.save({ "hello.py": GenConanfile().with_settings( "os", "arch", "compiler", "build_type").with_package_info( cpp_info={"frameworks": ['CoreFoundation']}, env_info={}) }) client.run("export hello.py hello/0.1@") main = textwrap.dedent(""" #include <CoreFoundation/CoreFoundation.h> int main(int argc, char *argv[]) { CFShow(CFSTR("Hello!")); } """) project_name = "app" client.save( { "conanfile.txt": "[requires]\nhello/0.1\n", "main.cpp": main, "project.yml": xcode_project }, clean_first=True) client.run( "install . -s build_type=Release -s arch=x86_64 --build=missing -g XcodeDeps" ) client.run_command("xcodegen generate") client.run_command( "xcodebuild -project app.xcodeproj -configuration Release -arch x86_64" ) client.run_command("./build/Release/{}".format(project_name)) assert "Hello!" in client.out
def test_xcodedeps_dashes_names_and_arch(): # https://github.com/conan-io/conan/issues/9949 client = TestClient(path_with_spaces=False) client.save({ "conanfile.py": GenConanfile().with_name("hello-dashes").with_version("0.1") }) client.run("export .") main = "int main(int argc, char *argv[]) { return 0; }" client.save( { "conanfile.txt": "[requires]\nhello-dashes/0.1\n", "main.cpp": main, "project.yml": xcode_project }, clean_first=True) client.run("install . -s arch=armv8 --build=missing -g XcodeDeps") assert os.path.exists( os.path.join( client.current_folder, "conan_hello_dashes_hello_dashes_vars_release_arm64.xcconfig")) client.run_command("xcodegen generate") client.run_command("xcodebuild -project app.xcodeproj -arch arm64") assert "BUILD SUCCEEDED" in client.out
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=19.1 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 = client.load("conanbuild.json") assert '"cmake_generator": "Ninja"' in conanbuild if platform.system() == "Windows": vcvars = client.load("conanvcvars.bat") assert "2017" in vcvars