def test_toolchain_win(self, compiler, version, runtime, cppstd): client = TestClient(path_with_spaces=False) settings = { "compiler": compiler, "compiler.version": version, "compiler.cppstd": cppstd, "compiler.runtime": runtime, "build_type": "Release", "arch": "x86" } profile = textwrap.dedent(""" [settings] os=Windows [conf] tools.microsoft.msbuild:vs_version=15 """) client.save({"myprofile": profile}) # Build the profile according to the settings provided settings = " ".join('-s %s="%s"' % (k, v) for k, v in settings.items() if v) client.run("new hello/0.1 -m=v2_cmake") client.run("create . hello/0.1@ %s" % (settings, )) # Prepare the actual consumer package client.save( { "conanfile.py": self.conanfile, "MyProject.sln": sln_file, "MyApp/MyApp.vcxproj": myapp_vcxproj, "MyApp/MyApp.cpp": self.app, "myprofile": profile }, clean_first=True) # Run the configure corresponding to this test case client.run("install . %s -if=conan -pr=myprofile" % (settings, )) self.assertIn( "conanfile.py: MSBuildToolchain created conantoolchain_release_win32.props", client.out) client.run("build . -if=conan") self.assertIn("Visual Studio 2017", client.out) self.assertIn("[vcvarsall.bat] Environment initialized for: 'x86'", client.out) self._run_app(client, "x86", "Release") self.assertIn("Hello World Release", client.out) compiler_version = version if compiler == "msvc" else "19.1" check_exe_run(client.out, "main", "msvc", compiler_version, "Release", "x86", cppstd, { "DEFINITIONS_BOTH": "True", "DEFINITIONS_CONFIG": "Release" }) check_vs_runtime("Release/MyApp.exe", client, "15", static=True, build_type="Release")
def test_locally_build_msvc(build_type, shared, client): msvc_version = "15" settings = "-s build_type={} -o hello:shared={}".format(build_type, shared) client.run("install . {}".format(settings)) client.run_command('conanvcvars.bat && cmake . -G "Ninja" ' '-DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake ' '-DCMAKE_BUILD_TYPE={}'.format(build_type)) client.run_command("conanvcvars.bat && ninja") libname = "mylibrary.dll" if shared else "mylibrary.lib" assert libname in client.out client.run_command("myapp.exe") # TODO: Need full msvc version check check_exe_run(client.out, ["main", "hello"], "msvc", "19", build_type, "x86_64", cppstd="14") check_vs_runtime("myapp.exe", client, msvc_version, build_type, architecture="amd64") check_vs_runtime(libname, client, msvc_version, build_type, architecture="amd64") # create should also work client.run("create . hello/1.0@ {}".format(settings)) assert 'cmake -G "Ninja"' in client.out assert "main: {}!".format(build_type) in client.out client.run("install hello/1.0@ -g=deploy -if=mydeploy {}".format(settings)) client.run_command(r"mydeploy\hello\myapp.exe") check_exe_run(client.out, ["main", "hello"], "msvc", "19", build_type, "x86_64", cppstd="14")
def test_toolchain_win_debug(self): client = TestClient(path_with_spaces=False) settings = [("compiler", "Visual Studio"), ("compiler.version", "15"), ("compiler.toolset", "v140"), ("compiler.runtime", "MDd"), ("build_type", "Debug"), ("arch", "x86_64")] # Build the profile according to the settings provided settings = " ".join('-s %s="%s"' % (k, v) for k, v in settings if v) client.run("new hello/0.1 -s") client.run("create . hello/0.1@ %s" % (settings,)) # Prepare the actual consumer package client.save({"conanfile.py": self.conanfile, "MyProject.sln": sln_file, "MyApp/MyApp.vcxproj": myapp_vcxproj, "MyApp/MyApp.cpp": self.app}, clean_first=True) # Run the configure corresponding to this test case client.run("install . %s -if=conan" % (settings, )) self.assertIn("conanfile.py: MSBuildToolchain created conantoolchain_debug_x64.props", client.out) client.run("build . -if=conan") self.assertIn("Visual Studio 2017", client.out) self.assertIn("[vcvarsall.bat] Environment initialized for: 'x64'", client.out) self._run_app(client, "x64", "Debug") self.assertIn("Hello World Debug", client.out) check_exe_run(client.out, "main", "msvc", "19.0", "Debug", "x86_64", "14", {"DEFINITIONS_BOTH": "True", "DEFINITIONS_CONFIG": "Debug"}) check_vs_runtime("x64/Debug/MyApp.exe", client, "15", static=False, build_type="Debug")
def test_locally_build_msvc_toolset(client): msvc_version = "15" profile = textwrap.dedent(""" [settings] os=Windows compiler=msvc compiler.version=190 compiler.runtime=dynamic compiler.cppstd=14 build_type=Release arch=x86_64 [conf] tools.cmake.cmaketoolchain:generator=Ninja tools.microsoft.msbuild:vs_version = 15 """) client.save({"profile": profile}) client.run("install . -pr=profile") client.run_command('conanvcvars.bat && cmake . -G "Ninja" ' '-DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake ' '-DCMAKE_BUILD_TYPE=Release') client.run_command("conanvcvars.bat && ninja") client.run_command("myapp.exe") # Checking that compiler is indeed version 19.0, not 19.1-default of VS15 check_exe_run(client.out, ["main", "hello"], "msvc", "190", "Release", "x86_64", cppstd="14") check_vs_runtime("myapp.exe", client, msvc_version, "Release", architecture="amd64") check_vs_runtime("mylibrary.lib", client, msvc_version, "Release", architecture="amd64")
def test_locally_build_gcc(build_type, shared, client): """ Ninja build must proceed using default profile and cmake build (Windows Release) """ # FIXME: Note the gcc version is still incorrect gcc = ( "-s os=Windows -s compiler=gcc -s compiler.version=4.9 -s compiler.libcxx=libstdc++ " "-s arch=x86_64 -s build_type={}".format(build_type)) client.run("install . {} -o hello:shared={}".format(gcc, shared)) client.run_command('cmake . -G "Ninja" ' '-DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake ' '-DCMAKE_BUILD_TYPE={}'.format(build_type)) libname = "mylibrary.dll" if shared else "libmylibrary.a" client.run_command("ninja") assert libname in client.out client.run_command("myapp.exe") # TODO: Need full gcc version check check_exe_run(client.out, ["main", "hello"], "gcc", None, build_type, "x86_64", cppstd=None)
def test_locally_build_linux(build_type, shared, client): settings = "-s os=Linux -s arch=x86_64 -s build_type={} -o hello:shared={}".format( build_type, shared) client.run("install . {}".format(settings)) client.run_command('cmake . -G "Ninja" -DCMAKE_TOOLCHAIN_FILE={}'.format( CMakeToolchain.filename)) client.run_command('ninja') if shared: assert "Linking CXX shared library libmylibrary.so" in client.out else: assert "Linking CXX static library libmylibrary.a" in client.out client.run_command("./myapp") check_exe_run(client.out, ["main", "hello"], "gcc", None, build_type, "x86_64", cppstd=None) # create should also work client.run("create . hello/1.0@ {}".format(settings)) assert 'cmake -G "Ninja"' in client.out assert "main: {}!".format(build_type) in client.out client.run("install hello/1.0@ -g=deploy -if=mydeploy {}".format(settings)) ldpath = os.path.join(client.current_folder, "mydeploy", "hello", "lib") client.run_command( "LD_LIBRARY_PATH='{}' ./mydeploy/hello/bin/myapp".format(ldpath)) check_exe_run(client.out, ["main", "hello"], "gcc", None, build_type, "x86_64", cppstd=None)
def test_locally_build_msvc(build_type, shared, client): """ Ninja build must proceed using default profile and cmake build (Windows Release) """ msvc_version = "15" client.run("install . -s build_type={} -o hello:shared={}".format( build_type, shared)) client.run_command('conanvcvars.bat && cmake . -G "Ninja" ' '-DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake ' '-DCMAKE_BUILD_TYPE={}'.format(build_type)) client.run_command("conanvcvars.bat && ninja") libname = "mylibrary.dll" if shared else "mylibrary.lib" assert libname in client.out client.run_command("myapp.exe") # TODO: Need full msvc version check check_exe_run(client.out, ["main", "hello"], "msvc", "19", build_type, "x86_64", cppstd="14") check_vs_runtime("myapp.exe", client, msvc_version, build_type, architecture="amd64") check_vs_runtime(libname, client, msvc_version, build_type, architecture="amd64")
def build_windows_subsystem(profile, make_program): """ The AutotoolsDeps can be used also in pure Makefiles, if the makefiles follow the Autotools conventions """ # FIXME: cygwin in CI (my local machine works) seems broken for path with spaces client = TestClient(path_with_spaces=False) client.run("new hello/0.1 --template=cmake_lib") # TODO: Test Windows subsystems in CMake, at least msys is broken os.rename(os.path.join(client.current_folder, "test_package"), os.path.join(client.current_folder, "test_package2")) client.save({"profile": profile}) client.run("create . --profile=profile") main = gen_function_cpp(name="main", includes=["hello"], calls=["hello"]) makefile = gen_makefile(apps=["app"]) conanfile = textwrap.dedent(""" from conans import ConanFile from conan.tools.gnu import AutotoolsToolchain, Autotools, AutotoolsDeps class TestConan(ConanFile): requires = "hello/0.1" settings = "os", "compiler", "arch", "build_type" exports_sources = "Makefile" generators = "AutotoolsDeps", "AutotoolsToolchain" def build(self): autotools = Autotools(self) autotools.make() """) client.save({"app.cpp": main, "Makefile": makefile, "conanfile.py": conanfile, "profile": profile}, clean_first=True) client.run("install . --profile=profile") cmd = environment_wrap_command(["conanbuildenv", "conanautotoolstoolchain", "conanautotoolsdeps"], client.current_folder, make_program) client.run_command(cmd) client.run_command("app") # TODO: fill compiler version when ready check_exe_run(client.out, "main", "gcc", None, "Release", "x86_64", None) assert "hello/0.1: Hello World Release!" in client.out client.save({"app.cpp": gen_function_cpp(name="main", msg="main2", includes=["hello"], calls=["hello"])}) # Make sure it is newer t = time.time() + 1 touch(os.path.join(client.current_folder, "app.cpp"), (t, t)) client.run("build .") client.run_command("app") # TODO: fill compiler version when ready check_exe_run(client.out, "main2", "gcc", None, "Release", "x86_64", None, cxx11_abi=0) assert "hello/0.1: Hello World Release!" in client.out return client.out
def test_toolchain_mingw_win(self, build_type, libcxx, version, cppstd, arch, shared): # FIXME: The version and cppstd are wrong, toolchain doesn't enforce it settings = {"compiler": "gcc", "compiler.version": version, "compiler.libcxx": libcxx, "compiler.cppstd": cppstd, "arch": arch, "build_type": build_type, } options = {"shared": shared} install_out = self._run_build(settings, options) self.assertIn("WARN: Toolchain: Ignoring fPIC option defined for Windows", install_out) self.assertIn("The C compiler identification is GNU", self.client.out) toolchain_path = os.path.join(self.client.current_folder, "build", "conan_toolchain.cmake").replace("\\", "/") self.assertIn('CMake command: cmake -G "MinGW Makefiles" ' '-DCMAKE_TOOLCHAIN_FILE="{}"'.format(toolchain_path), self.client.out) assert '-DCMAKE_SH="CMAKE_SH-NOTFOUND"' in self.client.out def _verify_out(marker=">>"): cmake_vars = {"CMAKE_GENERATOR_PLATFORM": "", "CMAKE_BUILD_TYPE": build_type, "CMAKE_CXX_FLAGS": "-m64", "CMAKE_CXX_FLAGS_DEBUG": "-g", "CMAKE_CXX_FLAGS_RELEASE": "-O3 -DNDEBUG", "CMAKE_C_FLAGS": "-m64", "CMAKE_C_FLAGS_DEBUG": "-g", "CMAKE_C_FLAGS_RELEASE": "-O3 -DNDEBUG", "CMAKE_SHARED_LINKER_FLAGS": "-m64", "CMAKE_EXE_LINKER_FLAGS": "-m64", "CMAKE_CXX_STANDARD": cppstd, "CMAKE_CXX_EXTENSIONS": "OFF", "BUILD_SHARED_LIBS": "ON" if shared else "OFF"} if shared: self.assertIn("app_lib.dll", self.client.out) else: self.assertNotIn("app_lib.dll", self.client.out) out = str(self.client.out).splitlines() for k, v in cmake_vars.items(): self.assertIn("%s %s: %s" % (marker, k, v), out) _verify_out() self._run_app(build_type) check_exe_run(self.client.out, "main", "gcc", None, build_type, arch, None, {"MYVAR": "MYVAR_VALUE", "MYVAR_CONFIG": "MYVAR_{}".format(build_type.upper()), "MYDEFINE": "MYDEF_VALUE", "MYDEFINE_CONFIG": "MYDEF_{}".format(build_type.upper()) }) self._modify_code() time.sleep(2) self._incremental_build() _verify_out(marker="++>>") self._run_app(build_type, msg="AppImproved")
def check_toolchain_win(self, compiler, version, runtime, cppstd): client = TestClient(path_with_spaces=False) settings = [("compiler", compiler), ("compiler.version", version), ("compiler.cppstd", cppstd), ("compiler.runtime", runtime), ("build_type", "Release"), ("arch", "x86")] profile = textwrap.dedent(""" [settings] os=Windows [conf] tools.microsoft.msbuild:vs_version={vs_version} """.format(vs_version=self.vs_version)) client.save({"myprofile": profile}) # Build the profile according to the settings provided settings = " ".join('-s %s="%s"' % (k, v) for k, v in settings if v) client.run("new hello/0.1 -m=cmake_lib") client.run("create . hello/0.1@ %s" % (settings, )) # Prepare the actual consumer package client.save({"conanfile.py": self.conanfile, "MyProject.sln": sln_file, "MyApp/MyApp.vcxproj": myapp_vcxproj, "MyApp/MyApp.cpp": self.app, "myprofile": profile}, clean_first=True) # Run the configure corresponding to this test case client.run("install . %s -if=conan -pr=myprofile" % (settings, )) self.assertIn("conanfile.py: MSBuildToolchain created conantoolchain_release_win32.props", client.out) client.run("build . -if=conan") self.assertIn("Visual Studio {ide_year}".format(ide_year=self.ide_year), client.out) self.assertIn("[vcvarsall.bat] Environment initialized for: 'x86'", client.out) self._run_app(client, "x86", "Release") self.assertIn("Hello World Release", client.out) compiler_version = version if compiler == "msvc" else self.msvc_version check_exe_run(client.out, "main", "msvc", compiler_version, "Release", "x86", cppstd, {"DEFINITIONS_BOTH": 'True', "DEFINITIONS_BOTH2": "True", "DEFINITIONS_BOTH_INT": "123", "DEFINITIONS_CONFIG": 'Release', "DEFINITIONS_CONFIG2": 'Release', "DEFINITIONS_CONFIG_INT": "456"}) static_runtime = True if runtime == "static" or "MT" in runtime else False check_vs_runtime("Release/MyApp.exe", client, self.vs_version, build_type="Release", static_runtime=static_runtime)
def test_autotools_bash_complete(): client = TestClient(path_with_spaces=False) bash_path = tools_locations["msys2"]["system"]["path"][ "Windows"] + "/bash.exe" save( client.cache.new_config_path, textwrap.dedent(""" tools.microsoft.bash:subsystem=msys2 tools.microsoft.bash:path={} """.format(bash_path))) main = gen_function_cpp(name="main") # The autotools support for "cl" compiler (VS) is very limited, linking with deps doesn't # work but building a simple app do 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 from conan.tools.env import Environment class TestConan(ConanFile): settings = "os", "compiler", "arch", "build_type" exports_sources = "configure.ac", "Makefile.am", "main.cpp" generators = "AutotoolsToolchain" win_bash = True def build(self): # These commands will run in bash activating first the vcvars and # then inside the bash activating the 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 }) client.run("install . -s:b os=Windows -s:h os=Windows") client.run("build .") client.run_command("main.exe") check_exe_run(client.out, "main", "msvc", None, "Release", "x86_64", None) bat_contents = client.load("conanbuild.bat") assert "conanvcvars.bat" in bat_contents
def test_mingw64(self): """ 64-bit GCC, binaries for generic Windows (no dependency on MSYS runtime) """ client = TestClient() # pacman -S mingw-w64-x86_64-gcc self._build(client, generator="MinGW Makefiles") check_exe_run(client.out, "main", "gcc", None, "Debug", "x86_64", None) assert "__MINGW64__" in client.out assert "__CYGWIN__" not in client.out assert "__MSYS__" not in client.out
def test_mingw32(self): """ 32-bit GCC, binaries for generic Windows (no dependency on MSYS runtime) """ client = TestClient() # pacman -S mingw-w64-i686-gcc self._build(client) check_exe_run(client.out, "main", "gcc", None, "Debug", "x86", None) assert "__MINGW32__" in client.out assert "__CYGWIN__" not in client.out assert "__MSYS__" not in client.out
def test_msys(self): """ native MSYS environment, binaries depend on MSYS runtime (msys-2.0.dll) posix-compatible, intended to be run only in MSYS environment (not in pure Windows) """ client = TestClient() # pacman -S gcc self._build(client) check_exe_run(client.out, "main", "gcc", None, "Debug", "x86_64", None) assert "__MINGW32__" not in client.out assert "__MINGW64__" not in client.out assert "__MSYS__" in client.out
def test_cygwin(self): """ Cygwin environment, binaries depend on Cygwin runtime (cygwin1.dll) posix-compatible, intended to be run only in Cygwin environment (not in pure Windows) """ client = TestClient() # install "gcc-c++" and "make" packages self._build(client) check_exe_run(client.out, "main", "gcc", None, "Debug", "x86_64", None) assert "__CYGWIN__" in client.out assert "__MINGW32__" not in client.out assert "__MINGW64__" not in client.out assert "__MSYS__" not in client.out
def test_autotools(): client = TestClient(path_with_spaces=False) client.run("new hello/0.1 --template=cmake_lib") client.run("create .") 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 = "AutotoolsDeps", "AutotoolsToolchain" 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 }, clean_first=True) client.run("install .") client.run("build .") client.run_command("./main") cxx11_abi = 0 if platform.system() == "Linux" else None check_exe_run(client.out, "main", "gcc", None, "Release", "x86_64", None, cxx11_abi=cxx11_abi) assert "hello/0.1: Hello World Release!" in client.out
def test_locally_build_macos(build_type, shared, client): client.run('install . -s os=Macos -s arch=x86_64 -s build_type={} -o hello:shared={}' .format(build_type, shared)) client.run_command('cmake . -G"Ninja" -DCMAKE_TOOLCHAIN_FILE={}' .format(CMakeToolchain.filename)) client.run_command('ninja') if shared: assert "Linking CXX shared library libmylibrary.dylib" in client.out else: assert "Linking CXX static library libmylibrary.a" in client.out command_str = 'DYLD_LIBRARY_PATH="%s" ./myapp' % client.current_folder client.run_command(command_str) check_exe_run(client.out, ["main", "hello"], "apple-clang", None, build_type, "x86_64", cppstd=None)
def test_msvc_vs_versiontoolset(version, vs_version): settings = { "compiler": "msvc", "compiler.version": version, "compiler.runtime": "static", "compiler.cppstd": "14", "arch": "x86_64", "build_type": "Release", } client = TestClient() save(client.cache.new_config_path, "tools.microsoft.msbuild:vs_version={}".format(vs_version)) conanfile = textwrap.dedent(""" from conans import ConanFile from conan.tools.cmake import CMake class App(ConanFile): settings = "os", "arch", "compiler", "build_type" generators = "CMakeToolchain" options = {"shared": [True, False], "fPIC": [True, False]} default_options = {"shared": False, "fPIC": True} exports_sources = "*" def build(self): cmake = CMake(self) cmake.configure() cmake.build() self.run("Release\\myapp.exe") """) cmakelists = gen_cmakelists(appname="myapp", appsources=["app.cpp"]) main = gen_function_cpp(name="main") client.save({ "conanfile.py": conanfile, "CMakeLists.txt": cmakelists, "app.cpp": main, }) settings = " ".join('-s %s="%s"' % (k, v) for k, v in settings.items() if v) client.run("create . app/1.0@ {}".format(settings)) assert '-G "Visual Studio 15 2017"' in client.out check_exe_run(client.out, "main", "msvc", version, "Release", "x86_64", "14")
def test_locally_build_linux(build_type, shared, client): """ Ninja build must proceed using default profile and cmake build (Linux) """ client.run( 'install . -s os=Linux -s arch=x86_64 -s build_type={} -o hello:shared={}' .format(build_type, shared)) client.run_command('cmake . -G"Ninja" -DCMAKE_TOOLCHAIN_FILE={}'.format( CMakeToolchain.filename)) client.run_command('ninja') if shared: assert "Linking CXX shared library libmylibrary.so" in client.out else: assert "Linking CXX static library libmylibrary.a" in client.out client.run_command("./myapp") check_exe_run(client.out, ["main", "hello"], "gcc", None, build_type, "x86_64", cppstd=None)
def test_toolchain_win(self, compiler, build_type, runtime, version, cppstd, arch, toolset, shared): settings = { "compiler": compiler, "compiler.version": version, "compiler.toolset": toolset, "compiler.runtime": runtime, "compiler.cppstd": cppstd, "arch": arch, "build_type": build_type, } options = {"shared": shared} save(self.client.cache.new_config_path, "tools.cmake.cmaketoolchain:msvc_parallel_compile=1") install_out = self._run_build(settings, options) self.assertIn( "WARN: Toolchain: Ignoring fPIC option defined for Windows", install_out) # FIXME: Hardcoded VS version and partial toolset check toolchain_path = os.path.join(self.client.current_folder, "build", "conan_toolchain.cmake").replace( "\\", "/") self.assertIn( 'CMake command: cmake -G "Visual Studio 15 2017" ' '-DCMAKE_TOOLCHAIN_FILE="{}"'.format(toolchain_path), self.client.out) if toolset == "v140": self.assertIn("Microsoft Visual Studio 14.0", self.client.out) else: self.assertIn("Microsoft Visual Studio/2017", self.client.out) generator_platform = "x64" if arch == "x86_64" else "Win32" arch_flag = "x64" if arch == "x86_64" else "X86" shared_str = "ON" if shared else "OFF" vals = { "CMAKE_GENERATOR_PLATFORM": generator_platform, "CMAKE_BUILD_TYPE": "", "CMAKE_CXX_FLAGS": "/MP1 /DWIN32 /D_WINDOWS /GR /EHsc", "CMAKE_CXX_FLAGS_DEBUG": "/Zi /Ob0 /Od /RTC1", "CMAKE_CXX_FLAGS_RELEASE": "/O2 /Ob2 /DNDEBUG", "CMAKE_C_FLAGS": "/MP1 /DWIN32 /D_WINDOWS", "CMAKE_C_FLAGS_DEBUG": "/Zi /Ob0 /Od /RTC1", "CMAKE_C_FLAGS_RELEASE": "/O2 /Ob2 /DNDEBUG", "CMAKE_SHARED_LINKER_FLAGS": "/machine:%s" % arch_flag, "CMAKE_EXE_LINKER_FLAGS": "/machine:%s" % arch_flag, "CMAKE_CXX_STANDARD": cppstd, "CMAKE_CXX_EXTENSIONS": "OFF", "BUILD_SHARED_LIBS": shared_str } def _verify_out(marker=">>"): if shared: self.assertIn("app_lib.dll", self.client.out) else: self.assertNotIn("app_lib.dll", self.client.out) out = str(self.client.out).splitlines() for k, v in vals.items(): self.assertIn("%s %s: %s" % (marker, k, v), out) _verify_out() opposite_build_type = "Release" if build_type == "Debug" else "Debug" settings["build_type"] = opposite_build_type if runtime == "MTd": settings["compiler.runtime"] = "MT" if runtime == "MD": settings["compiler.runtime"] = "MDd" self._run_build(settings, options) self._run_app("Release", bin_folder=True) if compiler == "msvc": visual_version = version else: visual_version = "19.0" if toolset == "v140" else "19.1" check_exe_run( self.client.out, "main", "msvc", visual_version, "Release", arch, cppstd, { "MYVAR": "MYVAR_VALUE", "MYVAR_CONFIG": "MYVAR_RELEASE", "MYDEFINE": "MYDEF_VALUE", "MYDEFINE_CONFIG": "MYDEF_RELEASE" }) self._run_app("Debug", bin_folder=True) check_exe_run( self.client.out, "main", "msvc", visual_version, "Debug", arch, cppstd, { "MYVAR": "MYVAR_VALUE", "MYVAR_CONFIG": "MYVAR_DEBUG", "MYDEFINE": "MYDEF_VALUE", "MYDEFINE_CONFIG": "MYDEF_DEBUG" }) static_runtime = True if runtime == "static" or "MT" in runtime else False check_vs_runtime("build/Release/app.exe", self.client, "15", build_type="Release", static_runtime=static_runtime) check_vs_runtime("build/Debug/app.exe", self.client, "15", build_type="Debug", static_runtime=static_runtime) self._modify_code() time.sleep(1) self._incremental_build(build_type=build_type) _verify_out(marker="++>>") self._run_app(build_type, bin_folder=True, msg="AppImproved") self._incremental_build(build_type=opposite_build_type) self._run_app(opposite_build_type, bin_folder=True, msg="AppImproved")
def test_toolchain_win_multi(self): client = TestClient(path_with_spaces=False) settings = { "compiler": "Visual Studio", "compiler.version": "15", "compiler.cppstd": "17" } settings = " ".join('-s %s="%s"' % (k, v) for k, v in settings.items() if v) client.run("new hello/0.1 -s") configs = [("Release", "x86", True), ("Release", "x86_64", True), ("Debug", "x86", False), ("Debug", "x86_64", False)] for build_type, arch, shared in configs: # Build the profile according to the settings provided runtime = "MT" if build_type == "Release" else "MTd" client.run( "create . hello/0.1@ %s -s build_type=%s -s arch=%s -s compiler.runtime=%s " " -o hello:shared=%s" % (settings, build_type, arch, runtime, shared)) # Prepare the actual consumer package client.save( { "conanfile.py": self.conanfile, "MyProject.sln": sln_file, "MyApp/MyApp.vcxproj": myapp_vcxproj, "MyApp/MyApp.cpp": self.app }, clean_first=True) # Run the configure corresponding to this test case for build_type, arch, shared in configs: runtime = "MT" if build_type == "Release" else "MTd" client.run( "install . %s -s build_type=%s -s arch=%s -s compiler.runtime=%s -if=conan" " -o hello:shared=%s" % (settings, build_type, arch, runtime, shared)) vs_path = vs_installation_path("15") vcvars_path = os.path.join(vs_path, "VC/Auxiliary/Build/vcvarsall.bat") for build_type, arch, shared in configs: platform_arch = "x86" if arch == "x86" else "x64" if build_type == "Release" and shared: configuration = "ReleaseShared" else: configuration = build_type # The "conan build" command is not good enough, cannot do the switch between configs cmd = ('set "VSCMD_START_DIR=%%CD%%" && ' '"%s" x64 && msbuild "MyProject.sln" /p:Configuration=%s ' '/p:Platform=%s ' % (vcvars_path, configuration, platform_arch)) client.run_command(cmd) self.assertIn("Visual Studio 2017", client.out) self.assertIn("[vcvarsall.bat] Environment initialized for: 'x64'", client.out) self._run_app(client, arch, build_type, shared) check_exe_run(client.out, "main", "msvc", "19.1", build_type, arch, "17", { "DEFINITIONS_BOTH": "True", "DEFINITIONS_CONFIG": build_type }) new_cmd = "conan\\%s\\%s\\MyApp.exe" % (arch, configuration) vcvars = vcvars_command(version="15", architecture="amd64") cmd = ('%s && dumpbin /dependents "%s"' % (vcvars, new_cmd)) client.run_command(cmd) if shared: self.assertIn("hello.dll", client.out) else: self.assertNotIn("hello.dll", client.out) self.assertIn("KERNEL32.dll", client.out)