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"))
