def test(self): with tools.environment_append(RunEnvironment(self).vars): command = 'node test.js {0}/bin/plugin.node {0}/bin/case-converter-plugin{1}'.format( os.path.abspath('.'), self._EXT()) self.run(command, cwd=os.path.dirname(__file__))
def test(self): if tools.cross_building(self.settings): print("NOT RUN (cross-building)") return # swig_python if self.options["casadi"].swig_python: self.output.info("Try to load 'casadi' python module") try: import casadi A = casadi.SX.eye(2) if casadi.trace(A) == 2: self.output.info("Completed conanized casadi climax") except ModuleNotFoundError: try: import numpy except ModuleNotFoundError: self.output.error("Casadi requires 'numpy', but it was not found") self.output.error("Unable to proplerly load python casadi module") self.output.info("Run consumer tests for library interfaces") cmake = self._configure_cmake() if self.options["casadi"].hpmpc: self.output.warn("HPMPC plugin interface is not tested") if self.options["casadi"].dsdp: self.output.warn("DSDP interface is not tested(?)") env_build = RunEnvironment(self) with tools.environment_append(env_build.vars): cmake.test() self.output.info("Casadi OK!")
def build(self): self.cmake.build() if self.options.build_testing: env_build = RunEnvironment(self) with tools.environment_append(env_build.vars): self.cmake.test(output_on_failure=True)
def package(self): self.copy(pattern="COPYING", dst="licenses", src=self._source_subfolder) # Execute install if self.settings.compiler == "Visual Studio" or self._is_win_x_android: cmake = self._configure_cmake() cmake.install() else: env_run = RunEnvironment(self) with tools.environment_append(env_run.vars): with tools.chdir(self._source_subfolder): autotools, autotools_vars = self._configure_autotools() autotools.install(vars=autotools_vars) if self._is_mingw: # Handle only mingw libs self.copy(pattern="*.dll", dst="bin", keep_path=False) self.copy(pattern="*dll.a", dst="lib", keep_path=False) self.copy(pattern="*.def", dst="lib", keep_path=False) self.copy(pattern="*.lib", dst="lib", keep_path=False) self.copy("cacert.pem", dst="res") # no need to distribute share folder (docs/man pages) tools.rmdir(os.path.join(self.package_folder, "share")) # no need for pc files tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig")) # no need for cmake files tools.rmdir(os.path.join(self.package_folder, "lib", "cmake")) # Remove libtool files (*.la) if os.path.isfile( os.path.join(self.package_folder, "lib", "libcurl.la")): os.remove(os.path.join(self.package_folder, "lib", "libcurl.la"))
def test(self): config_file = os.path.join(self.deps_cpp_info["macchina.io"].res_paths[0], "macchina.properties") bundles_dir = os.path.join(self.deps_cpp_info["macchina.io"].lib_paths[0], "bundles") _, pid_file = tempfile.mkstemp() env_build = RunEnvironment(self) env_vars = env_build.vars env_vars["PATH"] = "bin" env_vars["LD_LIBRARY_PATH"].append(os.path.join("bin", "codeCache")) assert(os.path.join(self.deps_cpp_info["macchina.io"].res_paths[0], "macchina.pem")) os.symlink(os.path.join(self.deps_cpp_info["macchina.io"].res_paths[0], "macchina.pem"), os.path.join("bin", "macchina.pem")) os.symlink(os.path.join(self.deps_cpp_info["macchina.io"].res_paths[0], "rootcert.pem"), os.path.join("bin", "rootcert.pem")) with tools.environment_append(env_vars): suffix = "d" if self.settings.build_type == "Debug" else "" self.run("macchina%s --daemon -B%s -c%s --pidfile=%s" % (suffix, bundles_dir, config_file, pid_file)) # Wait for server get ready time.sleep(5) try: conn = httplib.HTTPConnection("localhost", 22080) conn.request("HEAD", "/macchina/login") res = conn.getresponse() assert(res.status == 200) assert("OSP Web Server" in str(res.msg)) finally: with open(pid_file) as f: os.kill(int(f.read()), signal.SIGTERM)
def build(self): cmake = self.configure_cmake() cmake.build() if self.is_tests_enabled(): env_run = RunEnvironment(self) with tools.environment_append(env_run.vars): cmake.test(output_on_failure=True)
def _configure_autotools(self): if not self._autotools: self._autotools = AutoToolsBuildEnvironment(self) args = [] # FIXME: add dbus when #2147 is merged for lib in ["alsa", "x11", "openssl"]: args.append("--%s-%s" % ("enable" if getattr(self.options, "with_" + lib) else "disable", lib)) args.append("--%s-glib2" % ("enable" if self.options.with_glib else "disable")) args.append("--%s-fftw" % ("with" if self.options.with_fftw else "without")) if self.options.shared: args.extend(["--enable-shared=yes", "--enable-static=no"]) else: args.extend(["--enable-shared=no", "--enable-static=yes"]) args.append( "--with-udev-rules-dir=%s" % os.path.join(self.package_folder, "bin", "udev", "rules.d")) args.append("--with-systemduserunitdir=%s" % os.path.join(self.build_folder, "ignore")) with tools.environment_append( {"PKG_CONFIG_PATH": self.build_folder}): with tools.environment_append( { "FFTW_CFLAGS": tools.PkgConfig("fftw").cflags, "FFTW_LIBS": tools.PkgConfig("fftw").libs }) if self.options.with_fftw else tools.no_op(): with tools.environment_append(RunEnvironment(self).vars): self._autotools.configure( args=args, configure_dir=self._source_subfolder) return self._autotools
def build(self): cmake = self._configure_cmake() environ_backup = os.environ.copy() os.environ['CONAN_CPU_COUNT'] = '2' try: if self.settings.os == "Macos": # run_environment does not work here because it appends path just from # requirements, not from this package itself # https://docs.conan.io/en/latest/reference/build_helpers/run_environment.html#runenvironment lib_path = os.path.join(self.build_folder, "lib") self.run("DYLD_LIBRARY_PATH={0} cmake --build . {1}".format( lib_path, cmake.build_config)) else: cmake.build() finally: os.environ.clear() os.environ.update(environ_backup) if self.options.with_tests: env_build = RunEnvironment(self) with tools.environment_append(env_build.vars): cmake.parallel = False cmake.verbose = True cmake.test(output_on_failure=True)
def build(self): # Build without protoc os.mkdir("without_protoc") shutil.copy( os.path.join( self.source_folder, "addressbook.{}.pb.h".format( self.deps_cpp_info["protobuf"].version)), os.path.join("without_protoc", "addressbook.pb.h")) shutil.copy( os.path.join( self.source_folder, "addressbook.{}.pb.cc".format( self.deps_cpp_info["protobuf"].version)), os.path.join("without_protoc", "addressbook.pb.cc")) cmake = CMake(self) cmake.definitions["protobuf_VERBOSE"] = True cmake.definitions["protobuf_MODULE_COMPATIBLE"] = True cmake.definitions["PROTOC_AVAILABLE"] = False cmake.configure(build_folder="without_protoc") cmake.build() with tools.environment_append(RunEnvironment(self).vars): if self._protoc_available: # Build with protoc cmake = CMake(self) cmake.definitions["protobuf_VERBOSE"] = True cmake.definitions["protobuf_MODULE_COMPATIBLE"] = True cmake.definitions["PROTOC_AVAILABLE"] = True cmake.configure(build_folder="with_protoc") cmake.build()
def package(self): env_build = RunEnvironment(self) with tools.environment_append(env_build.vars): cmake = self._configure_cmake() cmake.install() self.copy("*.pdb", dst="lib") restatic = re.compile('(.*[.]a$)|(.*-static[.]lib)') redll = re.compile('.*[.]dll$') for root, dirs, files in os.walk(os.path.join(self.package_folder, 'lib')): for file in files: if (self.options.shared and restatic.match(file)) or \ (not self.options.shared and not restatic.match(file)): os.remove(os.path.join(root,file)) if not self.options.shared and self.settings.os == "Windows": for root, dirs, files in os.walk(os.path.join(self.package_folder, 'bin')): for file in files: if redll.match(file): os.remove(os.path.join(root,file)) if self.settings.os == "Windows": tools.rmdir(os.path.join(self.package_folder,'cmake')) if os.path.exists(os.path.join(self.package_folder, 'mathgl2-config.cmake')): os.remove(os.path.join(self.package_folder, 'mathgl2-config.cmake')) else: tools.rmdir(os.path.join(self.package_folder,'lib','cmake')) self.copy('COPYING', dst="licenses", src=self.source_subfolder, ignore_case=True, keep_path=False) if self.options.lgpl: self.copy('COPYING_LGPL', dst="licenses", src=self.source_subfolder, ignore_case=True, keep_path=False) if self.options.shared: self.copy("*", dst="licenses", src="licenses", keep_path=True)
def package(self): env_build = RunEnvironment(self) with tools.environment_append(env_build.vars): cmake = self._configure_cmake() self.run('cmake "%s" %s' % (self.source_folder, cmake.command_line), run_environment=True) self.run("cmake --build . %s" % cmake.build_config, run_environment=True) self.run("cmake --build . --target install", run_environment=True) self.copy(pattern="LICENSE", dst="licenses") self.copy("*", dst="include", src="{}/include".format(self._source_subfolder)) self.copy("*.cmake", dst="lib", src="{}/lib".format(self._build_subfolder), keep_path=True) self.copy("*.lib", dst="lib", src="", keep_path=False) self.copy("*.a", dst="lib", src="", keep_path=False) self.copy("*", dst="bin", src="bin") self.copy("*.dll", dst="bin", keep_path=False) self.copy("*.so", dst="lib", keep_path=False) self.copy("*.dylib", dst="lib", keep_path=False)
def cmake(self): if self._cmake is None: self._cmake = CMake(self) ccp_path = os.path.join(self.build_folder, "ComputeCpp-CE-1.1.6-Ubuntu-16.04-x86_64") exp_benchmarks = self.options.build_expression_benchmarks clblast_benchmarks = self.options.build_clblast_benchmarks config = { "ACL_BACKEND": str(self.options.acl_backend).upper(), "BLAS_ENABLE_BENCHMARK": self.options.build_benchmarks, "BLAS_ENABLE_TESTING": self.options.build_testing, "BLAS_VERIFY_BENCHMARK": self.options.build_benchmarks, "BUILD_ACL_BENCHMARKS": self.options.build_acl_benchmarks, "BUILD_CLBLAST_BENCHMARKS": clblast_benchmarks, "BUILD_EXPRESSION_BENCHMARKS": exp_benchmarks, "COMPUTECPP_BITCODE": self.options.sycl_target, "ComputeCpp_DIR": ccp_path, "ENABLE_EXPRESSION_TESTS": self.options.build_expression_tests, } self._cmake.definitions.update(config) with tools.environment_append(RunEnvironment(self).vars): self._cmake.configure() return self._cmake
def test(self): with tools.environment_append(RunEnvironment(self).vars): if self.settings.os == "Windows": self.run(os.path.join("bin", "test_package")) else: self.run("DYLD_LIBRARY_PATH=%s %s" % (os.environ['DYLD_LIBRARY_PATH'], os.path.join("bin", "test_package")))
def package(self): be = AutoToolsBuildEnvironment(self) re = RunEnvironment(self) with tools.chdir(self._source_subfolder): with tools.environment_append(be.vars): with tools.environment_append(re.vars): be.install()
def build_with_make(self): win_bash = tools.os_info.detect_windows_subsystem() == "msys2" with tools.environment_append(RunEnvironment(self).vars): self.run("./autogen.sh", win_bash=win_bash, cwd=self._source_subfolder) autotools = AutoToolsBuildEnvironment(self, win_bash=win_bash) args = [ "--with-freetype-prefix=" + self.deps_cpp_info["freetype"].rootpath, "--with-sdl-prefix=" + self.deps_cpp_info["sdl2"].rootpath, ] if self.options.shared: args.extend(['--enable-shared', '--disable-static']) else: args.extend(['--enable-static', '--disable-shared']) autotools.configure(configure_dir=self._source_subfolder, args=args) patches = ( ('\nnoinst_PROGRAMS = ', '\n# Removed by conan: noinst_PROGRAMS = '), ('\nLIBS = ', '\n# Removed by conan: LIBS = '), ('\nLIBTOOL = ', '\nLIBS = {}\nLIBTOOL = '.format(" ".join(["-l%s" % lib for lib in self.deps_cpp_info.libs]))), ('\nSDL_CFLAGS =', '\n# Removed by conan: SDL_CFLAGS ='), ('\nSDL_LIBS =' , '\n# Removed by conan: SDL_LIBS ='), ) for old_str, new_str in patches: tools.replace_in_file("Makefile", old_str, new_str) autotools.make() autotools.install()
def test(self): with tools.environment_append(RunEnvironment(self).vars): #so it can run on systems without display in case Qt is enabled... os.environ["QT_QPA_PLUGIN"] = "minimnal" bin_path = os.path.join("bin", "test_g4_find_package") self.run(bin_path)
def test(self): argument = "with_sctp" if self.options['lksctp-tools'].with_sctp else "" with tools.environment_append(RunEnvironment(self).vars): bin_path = os.path.join("bin", "test_package") self.run( "LD_LIBRARY_PATH=%s %s %s" % (os.environ.get('LD_LIBRARY_PATH', ''), bin_path, argument))
def build(self): version_major = tools.Version(self.version).major env_build = RunEnvironment(self) for patch in self.conan_data.get("patches", {}).get(self.version, []): tools.patch(**patch) cmake = self._configure_cmake() cmake.build()
def build(self): if not tools.cross_building(self, skip_x64_x86=True): command = "{} --version".format(self.deps_user_info["cpython"].python) buffer = StringIO() self.run(command, output=buffer, ignore_errors=True, run_environment=True) self.output.info("output: %s" % buffer.getvalue()) self.run(command, run_environment=True) cmake = CMake(self) py_major = self.deps_cpp_info["cpython"].version.split(".")[0] cmake.definitions["BUILD_MODULE"] = self._supports_modules cmake.definitions["PY_VERSION_MAJOR"] = py_major cmake.definitions["PY_VERSION_MAJOR_MINOR"] = ".".join(self._py_version.split(".")[:2]) cmake.definitions["PY_FULL_VERSION"] = self.deps_cpp_info["cpython"].version cmake.definitions["PY_VERSION"] = self._py_version cmake.definitions["PY_VERSION_SUFFIX"] = self._cmake_abi.suffix cmake.definitions["PYTHON_EXECUTABLE"] = self.deps_user_info["cpython"].python cmake.definitions["USE_FINDPYTHON_X".format(py_major)] = self._cmake_try_FindPythonX cmake.definitions["Python{}_EXECUTABLE".format(py_major)] = self.deps_user_info["cpython"].python cmake.definitions["Python{}_ROOT_DIR".format(py_major)] = self.deps_cpp_info["cpython"].rootpath cmake.definitions["Python{}_USE_STATIC_LIBS".format(py_major)] = not self.options["cpython"].shared cmake.definitions["Python{}_FIND_FRAMEWORK".format(py_major)] = "NEVER" cmake.definitions["Python{}_FIND_REGISTRY".format(py_major)] = "NEVER" cmake.definitions["Python{}_FIND_IMPLEMENTATIONS".format(py_major)] = "CPython" cmake.definitions["Python{}_FIND_STRATEGY".format(py_major)] = "LOCATION" if self.settings.compiler != "Visual Studio": if tools.Version(self._py_version) < tools.Version("3.8"): cmake.definitions["Python{}_FIND_ABI".format(py_major)] = self._cmake_abi.cmake_arg with tools.environment_append(RunEnvironment(self).vars): cmake.configure() cmake.build() if not tools.cross_building(self, skip_x64_x86=True): if self._supports_modules: with tools.vcvars(self.settings) if self.settings.compiler == "Visual Studio" else tools.no_op(): modsrcfolder = "py2" if tools.Version(self.deps_cpp_info["cpython"].version).major < "3" else "py3" tools.mkdir(os.path.join(self.build_folder, modsrcfolder)) for fn in os.listdir(os.path.join(self.source_folder, modsrcfolder)): shutil.copy(os.path.join(self.source_folder, modsrcfolder, fn), os.path.join(self.build_folder, modsrcfolder, fn)) shutil.copy(os.path.join(self.source_folder, "setup.py"), os.path.join(self.build_folder, "setup.py")) env = { "DISTUTILS_USE_SDK": "1", "MSSdk": "1" } env.update(**AutoToolsBuildEnvironment(self).vars) with tools.environment_append(env): setup_args = [ "{}/setup.py".format(self.source_folder), # "conan", # "--install-folder", self.build_folder, "build", "--build-base", self.build_folder, "--build-platlib", os.path.join(self.build_folder, "lib_setuptools"), ] if self.settings.build_type == "Debug": setup_args.append("--debug") self.run("{} {}".format(self.deps_user_info["cpython"].python, " ".join("\"{}\"".format(a) for a in setup_args)), run_environment=True)
def build(self): for f in glob.glob("*.cmake"): tools.replace_in_file( f, "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:>", "", strict=False) tools.replace_in_file( f, "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,MODULE_LIBRARY>:>", "", strict=False) tools.replace_in_file( f, "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:>", "", strict=False) tools.replace_in_file( f, "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:-Wl,--export-dynamic>", "", strict=False) tools.replace_in_file( f, "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,MODULE_LIBRARY>:-Wl,--export-dynamic>", "", strict=False) with tools.vcvars( self.settings ) if self.settings.compiler == "Visual Studio" else tools.no_op(): # next lines force cmake package to be in PATH before the one provided by visual studio (vcvars) build_env = tools.RunEnvironment( self ).vars if self.settings.compiler == "Visual Studio" else {} build_env["MAKEFLAGS"] = "j%d" % tools.cpu_count() build_env["PKG_CONFIG_PATH"] = [self.build_folder] if self.settings.os == "Windows": build_env["PATH"].append( os.path.join(self.source_folder, "qt6", "gnuwin32", "bin")) if self.settings.compiler == "Visual Studio": # this avoids cmake using gcc from strawberryperl build_env["CC"] = "cl" build_env["CXX"] = "cl" with tools.environment_append(build_env): if tools.os_info.is_macos: open(".qmake.stash", "w").close() open(".qmake.super", "w").close() cmake = self._configure_cmake() if tools.os_info.is_macos: with open("bash_env", "w") as f: f.write('export DYLD_LIBRARY_PATH="%s"' % ":".join( RunEnvironment(self).vars["DYLD_LIBRARY_PATH"])) with tools.environment_append( {"BASH_ENV": os.path.abspath("bash_env") }) if tools.os_info.is_macos else tools.no_op(): with tools.run_environment(self): cmake.build()
def test(self): # Search for LICENSE file path = os.path.join(self.deps_cpp_info["json"].rootpath, "licenses", "LICENSE") assert os.path.isfile(path) # Validate package import with tools.environment_append(RunEnvironment(self).vars): bin_path = os.path.join("bin", "test_package") self.run(bin_path)
def _build_with_meson(self): if self.options["qtbase"].shared and not tools.cross_building(self.settings): self.output.info("Building with Meson") tools.mkdir("meson_folder") with tools.environment_append(RunEnvironment(self).vars): meson = Meson(self) meson.configure(build_folder="meson_folder", defs={"cpp_std": "c++11"}) meson.build()
def test(self): os.chdir("bin") self.run(os.path.join('.', 'example')) if self.settings.os != 'Windows': run_env = RunEnvironment(self) with tools.environment_append(run_env.vars): self.run('odbcinst --version')
def build(self): env_build = RunEnvironment(self) with tools.environment_append(env_build.vars): cmake = CMake(self) cmake.configure(defs={ "CMAKE_CXX_STANDARD": self._cmake_cxx_standard, }) cmake.build()
def test(self): with tools.environment_append(RunEnvironment(self).vars): bin_path = os.path.join("bin", "test_package") if self.settings.os == "Macos": self.run("DYLD_LIBRARY_PATH={} {}".format(os.environ.get("DYLD_LIBRARY_PATH", ""), bin_path)) else: self.run(bin_path) assert(os.path.exists(os.environ["TCLSH"]))
def test(self): with tools.chdir("bin"): env_build = RunEnvironment(self) with tools.environment_append(env_build.vars): if self.settings.os == "Windows": self.run("test_package") else: self.run("./test_package")
def test(self): with tools.environment_append(RunEnvironment(self).vars): bin_path = os.path.join("bin", "test_package") if self.settings.os == "Windows": self.run(bin_path) elif self.settings.os == "Macos": self.run("DYLD_LIBRARY_PATH=%s %s" % (os.environ.get('DYLD_LIBRARY_PATH', ''), bin_path)) else: self.run("LD_LIBRARY_PATH=%s %s" % (os.environ.get('LD_LIBRARY_PATH', ''), bin_path))
def test(self): with tools.environment_append(RunEnvironment(self).vars): bin_path = os.path.join("bin", "test_package") if self.settings.os == "Windows": self.run(bin_path, win_bash=tools.os_info.detect_windows_subsystem() == "msys2") elif self.settings.os == "Macos": self.run("DYLD_LIBRARY_PATH=%s %s" % (os.environ.get('DYLD_LIBRARY_PATH', ''), bin_path)) else: self.run("LD_LIBRARY_PATH=%s %s" % (os.environ.get('LD_LIBRARY_PATH', ''), bin_path))
def build_with_autotools(self): configure_suffix = self.get_configure_command_suffix() env_build = AutoToolsBuildEnvironment(self, win_bash=self.is_mingw) env_build_vars = env_build.vars # tweaks for mingw if self.is_mingw: # patch autotools files self.patch_mingw_files() env_build.defines.append('_AMD64_') env_build_vars['RCFLAGS'] = '-O COFF' if self.settings.arch == "x86": env_build_vars['RCFLAGS'] += ' --target=pe-i386' else: env_build_vars['RCFLAGS'] += ' --target=pe-x86-64' del env_build_vars['LIBS'] self.output.info(repr(env_build_vars)) if self.settings.os != "Windows": env_build.fpic = self.options.fPIC with tools.environment_append(env_build_vars): # temporary fix for xcode9 # extremely fragile because make doesn't see CFLAGS from env, only from cmdline if self.settings.os == "Macos": make_suffix = "CFLAGS=\"-Wno-unguarded-availability " + env_build.vars['CFLAGS'] + "\"" else: make_suffix = '' env_run = RunEnvironment(self) # run configure with *LD_LIBRARY_PATH env vars # it allows to pick up shared openssl self.output.info(repr(env_run.vars)) with tools.environment_append(env_run.vars): with tools.chdir(self.source_subfolder): # autoreconf self.run('./buildconf', win_bash=self.is_mingw) # fix generated autotools files tools.replace_in_file("configure", "-install_name \\$rpath/", "-install_name ") # BUG: https://github.com/curl/curl/commit/bd742adb6f13dc668ffadb2e97a40776a86dc124 # fixed in 7.54.1: https://github.com/curl/curl/commit/338f427a24f78a717888c7c2b6b91fa831bea28e if self.version_components[0] == 7 and self.version_components[1] < 55: tools.replace_in_file( "configure", 'LDFLAGS="`$PKGCONFIG --libs-only-L zlib` $LDFLAGS"', 'LDFLAGS="$LDFLAGS `$PKGCONFIG --libs-only-L zlib`"') self.run("chmod +x configure") self.run("./configure " + configure_suffix, win_bash=self.is_mingw) self.run("make %s" % make_suffix, win_bash=self.is_mingw) self.run("make %s install" % make_suffix, win_bash=self.is_mingw)
def test(self): bin_dir = os.path.join(os.getcwd(), "bin") lib_dir = os.path.join(os.getcwd(), "lib") with tools.environment_append(RunEnvironment(self).vars): if self.settings.os == "Windows": self.run(os.path.join("bin","test_package")) else: with tools.environment_append({"LD_LIBRARY_PATH": lib_dir, "DYLD_LIBRARY_PATH": lib_dir}): self.run(os.path.join("bin","test_package"))