| # Copyright 2016-2022 The Meson development team |
| |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import stat |
| import subprocess |
| import re |
| import tempfile |
| import textwrap |
| import os |
| import shutil |
| import hashlib |
| from unittest import mock, skipUnless, SkipTest |
| from glob import glob |
| from pathlib import Path |
| import typing as T |
| |
| import mesonbuild.mlog |
| import mesonbuild.depfile |
| import mesonbuild.dependencies.base |
| import mesonbuild.dependencies.factory |
| import mesonbuild.envconfig |
| import mesonbuild.environment |
| import mesonbuild.coredata |
| import mesonbuild.modules.gnome |
| from mesonbuild.mesonlib import ( |
| MachineChoice, is_windows, is_osx, is_cygwin, is_openbsd, is_haiku, |
| is_sunos, windows_proof_rmtree, version_compare, is_linux, |
| OptionKey, EnvironmentException |
| ) |
| from mesonbuild.compilers import ( |
| detect_c_compiler, detect_cpp_compiler, compiler_from_language, |
| ) |
| from mesonbuild.compilers.c import AppleClangCCompiler |
| from mesonbuild.compilers.cpp import AppleClangCPPCompiler |
| from mesonbuild.compilers.objc import AppleClangObjCCompiler |
| from mesonbuild.compilers.objcpp import AppleClangObjCPPCompiler |
| from mesonbuild.dependencies.pkgconfig import PkgConfigDependency, PkgConfigCLI, PkgConfigInterface |
| import mesonbuild.modules.pkgconfig |
| |
| PKG_CONFIG = os.environ.get('PKG_CONFIG', 'pkg-config') |
| |
| |
| from run_tests import ( |
| get_fake_env |
| ) |
| |
| from .baseplatformtests import BasePlatformTests |
| from .helpers import * |
| |
| def _prepend_pkg_config_path(path: str) -> str: |
| """Prepend a string value to pkg_config_path |
| |
| :param path: The path to prepend |
| :return: The path, followed by any PKG_CONFIG_PATH already in the environment |
| """ |
| pkgconf = os.environ.get('PKG_CONFIG_PATH') |
| if pkgconf: |
| return f'{path}{os.path.pathsep}{pkgconf}' |
| return path |
| |
| |
| def _clang_at_least(compiler: 'Compiler', minver: str, apple_minver: T.Optional[str]) -> bool: |
| """ |
| check that Clang compiler is at least a specified version, whether AppleClang or regular Clang |
| |
| Parameters |
| ---------- |
| compiler: |
| Meson compiler object |
| minver: str |
| Clang minimum version |
| apple_minver: str |
| AppleCLang minimum version |
| |
| Returns |
| ------- |
| at_least: bool |
| Clang is at least the specified version |
| """ |
| if isinstance(compiler, (AppleClangCCompiler, AppleClangCPPCompiler)): |
| if apple_minver is None: |
| return False |
| return version_compare(compiler.version, apple_minver) |
| return version_compare(compiler.version, minver) |
| |
| @skipUnless(not is_windows(), "requires something Unix-like") |
| class LinuxlikeTests(BasePlatformTests): |
| ''' |
| Tests that should run on Linux, macOS, and *BSD |
| ''' |
| |
| def test_basic_soname(self): |
| ''' |
| Test that the soname is set correctly for shared libraries. This can't |
| be an ordinary test case because we need to run `readelf` and actually |
| check the soname. |
| https://github.com/mesonbuild/meson/issues/785 |
| ''' |
| testdir = os.path.join(self.common_test_dir, '4 shared') |
| self.init(testdir) |
| self.build() |
| lib1 = os.path.join(self.builddir, 'libmylib.so') |
| soname = get_soname(lib1) |
| self.assertEqual(soname, 'libmylib.so') |
| |
| def test_custom_soname(self): |
| ''' |
| Test that the soname is set correctly for shared libraries when |
| a custom prefix and/or suffix is used. This can't be an ordinary test |
| case because we need to run `readelf` and actually check the soname. |
| https://github.com/mesonbuild/meson/issues/785 |
| ''' |
| testdir = os.path.join(self.common_test_dir, '24 library versions') |
| self.init(testdir) |
| self.build() |
| lib1 = os.path.join(self.builddir, 'prefixsomelib.suffix') |
| soname = get_soname(lib1) |
| self.assertEqual(soname, 'prefixsomelib.suffix') |
| |
| def test_pic(self): |
| ''' |
| Test that -fPIC is correctly added to static libraries when b_staticpic |
| is true and not when it is false. This can't be an ordinary test case |
| because we need to inspect the compiler database. |
| ''' |
| if is_windows() or is_cygwin() or is_osx(): |
| raise SkipTest('PIC not relevant') |
| |
| testdir = os.path.join(self.common_test_dir, '3 static') |
| self.init(testdir) |
| compdb = self.get_compdb() |
| self.assertIn('-fPIC', compdb[0]['command']) |
| self.setconf('-Db_staticpic=false') |
| # Regenerate build |
| self.build() |
| compdb = self.get_compdb() |
| self.assertNotIn('-fPIC', compdb[0]['command']) |
| |
| @mock.patch.dict(os.environ) |
| def test_pkgconfig_gen(self): |
| ''' |
| Test that generated pkg-config files can be found and have the correct |
| version and link args. This can't be an ordinary test case because we |
| need to run pkg-config outside of a Meson build file. |
| https://github.com/mesonbuild/meson/issues/889 |
| ''' |
| testdir = os.path.join(self.common_test_dir, '44 pkgconfig-gen') |
| self.init(testdir) |
| env = get_fake_env(testdir, self.builddir, self.prefix) |
| kwargs = {'required': True, 'silent': True} |
| os.environ['PKG_CONFIG_LIBDIR'] = self.privatedir |
| foo_dep = PkgConfigDependency('libfoo', env, kwargs) |
| self.assertTrue(foo_dep.found()) |
| self.assertEqual(foo_dep.get_version(), '1.0') |
| self.assertIn('-lfoo', foo_dep.get_link_args()) |
| self.assertEqual(foo_dep.get_variable(pkgconfig='foo'), 'bar') |
| self.assertPathEqual(foo_dep.get_variable(pkgconfig='datadir'), '/usr/data') |
| |
| libhello_nolib = PkgConfigDependency('libhello_nolib', env, kwargs) |
| self.assertTrue(libhello_nolib.found()) |
| self.assertEqual(libhello_nolib.get_link_args(), []) |
| self.assertEqual(libhello_nolib.get_compile_args(), []) |
| self.assertEqual(libhello_nolib.get_variable(pkgconfig='foo'), 'bar') |
| self.assertEqual(libhello_nolib.get_variable(pkgconfig='prefix'), self.prefix) |
| impl = libhello_nolib.pkgconfig |
| if not isinstance(impl, PkgConfigCLI) or version_compare(impl.pkgbin_version, ">=0.29.1"): |
| self.assertEqual(libhello_nolib.get_variable(pkgconfig='escaped_var'), r'hello\ world') |
| self.assertEqual(libhello_nolib.get_variable(pkgconfig='unescaped_var'), 'hello world') |
| |
| cc = detect_c_compiler(env, MachineChoice.HOST) |
| if cc.get_id() in {'gcc', 'clang'}: |
| for name in {'ct', 'ct0'}: |
| ct_dep = PkgConfigDependency(name, env, kwargs) |
| self.assertTrue(ct_dep.found()) |
| self.assertIn('-lct', ct_dep.get_link_args(raw=True)) |
| |
| def test_pkgconfig_gen_deps(self): |
| ''' |
| Test that generated pkg-config files correctly handle dependencies |
| ''' |
| testdir = os.path.join(self.common_test_dir, '44 pkgconfig-gen') |
| self.init(testdir) |
| privatedir1 = self.privatedir |
| |
| self.new_builddir() |
| testdir = os.path.join(self.common_test_dir, '44 pkgconfig-gen', 'dependencies') |
| self.init(testdir, override_envvars={'PKG_CONFIG_LIBDIR': privatedir1}) |
| privatedir2 = self.privatedir |
| |
| env = { |
| 'PKG_CONFIG_LIBDIR': os.pathsep.join([privatedir1, privatedir2]), |
| 'PKG_CONFIG_SYSTEM_LIBRARY_PATH': '/usr/lib', |
| } |
| self._run([PKG_CONFIG, 'dependency-test', '--validate'], override_envvars=env) |
| |
| # pkg-config strips some duplicated flags so we have to parse the |
| # generated file ourself. |
| expected = { |
| 'Requires': 'libexposed', |
| 'Requires.private': 'libfoo >= 1.0', |
| 'Libs': '-L${libdir} -llibmain -pthread -lcustom', |
| 'Libs.private': '-lcustom2 -L${libdir} -llibinternal', |
| 'Cflags': '-I${includedir} -pthread -DCUSTOM', |
| } |
| if is_osx() or is_haiku(): |
| expected['Cflags'] = expected['Cflags'].replace('-pthread ', '') |
| with open(os.path.join(privatedir2, 'dependency-test.pc'), encoding='utf-8') as f: |
| matched_lines = 0 |
| for line in f: |
| parts = line.split(':', 1) |
| if parts[0] in expected: |
| key = parts[0] |
| val = parts[1].strip() |
| expected_val = expected[key] |
| self.assertEqual(expected_val, val) |
| matched_lines += 1 |
| self.assertEqual(len(expected), matched_lines) |
| |
| cmd = [PKG_CONFIG, 'requires-test'] |
| out = self._run(cmd + ['--print-requires'], override_envvars=env).strip().split('\n') |
| if not is_openbsd(): |
| self.assertEqual(sorted(out), sorted(['libexposed', 'libfoo >= 1.0', 'libhello'])) |
| else: |
| self.assertEqual(sorted(out), sorted(['libexposed', 'libfoo>=1.0', 'libhello'])) |
| |
| cmd = [PKG_CONFIG, 'requires-private-test'] |
| out = self._run(cmd + ['--print-requires-private'], override_envvars=env).strip().split('\n') |
| if not is_openbsd(): |
| self.assertEqual(sorted(out), sorted(['libexposed', 'libfoo >= 1.0', 'libhello'])) |
| else: |
| self.assertEqual(sorted(out), sorted(['libexposed', 'libfoo>=1.0', 'libhello'])) |
| |
| cmd = [PKG_CONFIG, 'pub-lib-order'] |
| out = self._run(cmd + ['--libs'], override_envvars=env).strip().split() |
| self.assertEqual(out, ['-llibmain2', '-llibinternal']) |
| |
| # See common/44 pkgconfig-gen/meson.build for description of the case this test |
| with open(os.path.join(privatedir1, 'simple2.pc'), encoding='utf-8') as f: |
| content = f.read() |
| self.assertIn('Libs: -L${libdir} -lsimple2 -lsimple1', content) |
| self.assertIn('Libs.private: -lz', content) |
| |
| with open(os.path.join(privatedir1, 'simple3.pc'), encoding='utf-8') as f: |
| content = f.read() |
| self.assertEqual(1, content.count('-lsimple3')) |
| |
| with open(os.path.join(privatedir1, 'simple5.pc'), encoding='utf-8') as f: |
| content = f.read() |
| self.assertNotIn('-lstat2', content) |
| |
| @mock.patch.dict(os.environ) |
| def test_pkgconfig_uninstalled(self): |
| testdir = os.path.join(self.common_test_dir, '44 pkgconfig-gen') |
| self.init(testdir) |
| self.build() |
| |
| os.environ['PKG_CONFIG_LIBDIR'] = os.path.join(self.builddir, 'meson-uninstalled') |
| if is_cygwin(): |
| os.environ['PATH'] += os.pathsep + self.builddir |
| |
| self.new_builddir() |
| testdir = os.path.join(self.common_test_dir, '44 pkgconfig-gen', 'dependencies') |
| self.init(testdir) |
| self.build() |
| self.run_tests() |
| |
| def test_pkg_unfound(self): |
| testdir = os.path.join(self.unit_test_dir, '23 unfound pkgconfig') |
| self.init(testdir) |
| with open(os.path.join(self.privatedir, 'somename.pc'), encoding='utf-8') as f: |
| pcfile = f.read() |
| self.assertNotIn('blub_blob_blib', pcfile) |
| |
| def test_symlink_builddir(self) -> None: |
| ''' |
| Test using a symlink as either the builddir for "setup" or |
| the argument for "-C". |
| ''' |
| testdir = os.path.join(self.common_test_dir, '1 trivial') |
| |
| symdir = f'{self.builddir}-symlink' |
| os.symlink(self.builddir, symdir) |
| self.addCleanup(os.unlink, symdir) |
| self.change_builddir(symdir) |
| |
| self.init(testdir) |
| self.build() |
| self._run(self.mtest_command) |
| |
| def test_vala_c_warnings(self): |
| ''' |
| Test that no warnings are emitted for C code generated by Vala. This |
| can't be an ordinary test case because we need to inspect the compiler |
| database. |
| https://github.com/mesonbuild/meson/issues/864 |
| ''' |
| if not shutil.which('valac'): |
| raise SkipTest('valac not installed.') |
| testdir = os.path.join(self.vala_test_dir, '5 target glib') |
| self.init(testdir) |
| compdb = self.get_compdb() |
| vala_command = None |
| c_command = None |
| for each in compdb: |
| if each['file'].endswith('GLib.Thread.c'): |
| vala_command = each['command'] |
| elif each['file'].endswith('GLib.Thread.vala'): |
| continue |
| elif each['file'].endswith('retcode.c'): |
| c_command = each['command'] |
| else: |
| m = 'Unknown file {!r} in vala_c_warnings test'.format(each['file']) |
| raise AssertionError(m) |
| self.assertIsNotNone(vala_command) |
| self.assertIsNotNone(c_command) |
| # -w suppresses all warnings, should be there in Vala but not in C |
| self.assertIn(" -w ", vala_command) |
| self.assertNotIn(" -w ", c_command) |
| # -Wall enables all warnings, should be there in C but not in Vala |
| self.assertNotIn(" -Wall ", vala_command) |
| self.assertIn(" -Wall ", c_command) |
| # -Werror converts warnings to errors, should always be there since it's |
| # injected by an unrelated piece of code and the project has werror=true |
| self.assertIn(" -Werror ", vala_command) |
| self.assertIn(" -Werror ", c_command) |
| |
| @skipIfNoPkgconfig |
| def test_qtdependency_pkgconfig_detection(self): |
| ''' |
| Test that qt4 and qt5 detection with pkgconfig works. |
| ''' |
| # Verify Qt4 or Qt5 can be found with pkg-config |
| qt4 = subprocess.call([PKG_CONFIG, '--exists', 'QtCore']) |
| qt5 = subprocess.call([PKG_CONFIG, '--exists', 'Qt5Core']) |
| testdir = os.path.join(self.framework_test_dir, '4 qt') |
| self.init(testdir, extra_args=['-Dmethod=pkg-config']) |
| # Confirm that the dependency was found with pkg-config |
| mesonlog = self.get_meson_log_raw() |
| if qt4 == 0: |
| self.assertRegex(mesonlog, |
| r'Run-time dependency qt4 \(modules: Core\) found: YES 4.* \(pkg-config\)') |
| if qt5 == 0: |
| self.assertRegex(mesonlog, |
| r'Run-time dependency qt5 \(modules: Core\) found: YES 5.* \(pkg-config\)') |
| |
| @skip_if_not_base_option('b_sanitize') |
| def test_generate_gir_with_address_sanitizer(self): |
| if is_cygwin(): |
| raise SkipTest('asan not available on Cygwin') |
| if is_openbsd(): |
| raise SkipTest('-fsanitize=address is not supported on OpenBSD') |
| |
| testdir = os.path.join(self.framework_test_dir, '7 gnome') |
| self.init(testdir, extra_args=['-Db_sanitize=address', '-Db_lundef=false']) |
| self.build() |
| |
| def test_qt5dependency_qmake_detection(self): |
| ''' |
| Test that qt5 detection with qmake works. This can't be an ordinary |
| test case because it involves setting the environment. |
| ''' |
| # Verify that qmake is for Qt5 |
| if not shutil.which('qmake-qt5'): |
| if not shutil.which('qmake'): |
| raise SkipTest('QMake not found') |
| output = subprocess.getoutput('qmake --version') |
| if 'Qt version 5' not in output: |
| raise SkipTest('Qmake found, but it is not for Qt 5.') |
| # Disable pkg-config codepath and force searching with qmake/qmake-qt5 |
| testdir = os.path.join(self.framework_test_dir, '4 qt') |
| self.init(testdir, extra_args=['-Dmethod=qmake']) |
| # Confirm that the dependency was found with qmake |
| mesonlog = self.get_meson_log_raw() |
| self.assertRegex(mesonlog, |
| r'Run-time dependency qt5 \(modules: Core\) found: YES .* \(qmake\)\n') |
| |
| def test_qt6dependency_qmake_detection(self): |
| ''' |
| Test that qt6 detection with qmake works. This can't be an ordinary |
| test case because it involves setting the environment. |
| ''' |
| # Verify that qmake is for Qt6 |
| if not shutil.which('qmake6'): |
| if not shutil.which('qmake'): |
| raise SkipTest('QMake not found') |
| output = subprocess.getoutput('qmake --version') |
| if 'Qt version 6' not in output: |
| raise SkipTest('Qmake found, but it is not for Qt 6.') |
| # Disable pkg-config codepath and force searching with qmake/qmake-qt6 |
| testdir = os.path.join(self.framework_test_dir, '4 qt') |
| self.init(testdir, extra_args=['-Dmethod=qmake']) |
| # Confirm that the dependency was found with qmake |
| mesonlog = self.get_meson_log_raw() |
| self.assertRegex(mesonlog, |
| r'Run-time dependency qt6 \(modules: Core\) found: YES .* \(qmake\)\n') |
| |
| def glob_sofiles_without_privdir(self, g): |
| files = glob(g) |
| return [f for f in files if not f.endswith('.p')] |
| |
| def _test_soname_impl(self, libpath, install): |
| if is_cygwin() or is_osx(): |
| raise SkipTest('Test only applicable to ELF and linuxlike sonames') |
| |
| testdir = os.path.join(self.unit_test_dir, '1 soname') |
| self.init(testdir) |
| self.build() |
| if install: |
| self.install() |
| |
| # File without aliases set. |
| nover = os.path.join(libpath, 'libnover.so') |
| self.assertPathExists(nover) |
| self.assertFalse(os.path.islink(nover)) |
| self.assertEqual(get_soname(nover), 'libnover.so') |
| self.assertEqual(len(self.glob_sofiles_without_privdir(nover[:-3] + '*')), 1) |
| |
| # File with version set |
| verset = os.path.join(libpath, 'libverset.so') |
| self.assertPathExists(verset + '.4.5.6') |
| self.assertEqual(os.readlink(verset), 'libverset.so.4') |
| self.assertEqual(get_soname(verset), 'libverset.so.4') |
| self.assertEqual(len(self.glob_sofiles_without_privdir(verset[:-3] + '*')), 3) |
| |
| # File with soversion set |
| soverset = os.path.join(libpath, 'libsoverset.so') |
| self.assertPathExists(soverset + '.1.2.3') |
| self.assertEqual(os.readlink(soverset), 'libsoverset.so.1.2.3') |
| self.assertEqual(get_soname(soverset), 'libsoverset.so.1.2.3') |
| self.assertEqual(len(self.glob_sofiles_without_privdir(soverset[:-3] + '*')), 2) |
| |
| # File with version and soversion set to same values |
| settosame = os.path.join(libpath, 'libsettosame.so') |
| self.assertPathExists(settosame + '.7.8.9') |
| self.assertEqual(os.readlink(settosame), 'libsettosame.so.7.8.9') |
| self.assertEqual(get_soname(settosame), 'libsettosame.so.7.8.9') |
| self.assertEqual(len(self.glob_sofiles_without_privdir(settosame[:-3] + '*')), 2) |
| |
| # File with version and soversion set to different values |
| bothset = os.path.join(libpath, 'libbothset.so') |
| self.assertPathExists(bothset + '.1.2.3') |
| self.assertEqual(os.readlink(bothset), 'libbothset.so.1.2.3') |
| self.assertEqual(os.readlink(bothset + '.1.2.3'), 'libbothset.so.4.5.6') |
| self.assertEqual(get_soname(bothset), 'libbothset.so.1.2.3') |
| self.assertEqual(len(self.glob_sofiles_without_privdir(bothset[:-3] + '*')), 3) |
| |
| # A shared_module that is not linked to anything |
| module = os.path.join(libpath, 'libsome_module.so') |
| self.assertPathExists(module) |
| self.assertFalse(os.path.islink(module)) |
| self.assertEqual(get_soname(module), None) |
| |
| # A shared_module that is not linked to an executable with link_with: |
| module = os.path.join(libpath, 'liblinked_module1.so') |
| self.assertPathExists(module) |
| self.assertFalse(os.path.islink(module)) |
| self.assertEqual(get_soname(module), 'liblinked_module1.so') |
| |
| # A shared_module that is not linked to an executable with dependencies: |
| module = os.path.join(libpath, 'liblinked_module2.so') |
| self.assertPathExists(module) |
| self.assertFalse(os.path.islink(module)) |
| self.assertEqual(get_soname(module), 'liblinked_module2.so') |
| |
| def test_soname(self): |
| self._test_soname_impl(self.builddir, False) |
| |
| def test_installed_soname(self): |
| libdir = self.installdir + os.path.join(self.prefix, self.libdir) |
| self._test_soname_impl(libdir, True) |
| |
| def test_compiler_check_flags_order(self): |
| ''' |
| Test that compiler check flags override all other flags. This can't be |
| an ordinary test case because it needs the environment to be set. |
| ''' |
| testdir = os.path.join(self.common_test_dir, '36 has function') |
| env = get_fake_env(testdir, self.builddir, self.prefix) |
| cpp = detect_cpp_compiler(env, MachineChoice.HOST) |
| Oflag = '-O3' |
| OflagCPP = Oflag |
| if cpp.get_id() in ('clang', 'gcc'): |
| # prevent developers from adding "int main(int argc, char **argv)" |
| # to small Meson checks unless these parameters are actually used |
| OflagCPP += ' -Werror=unused-parameter' |
| env = {'CFLAGS': Oflag, |
| 'CXXFLAGS': OflagCPP} |
| self.init(testdir, override_envvars=env) |
| cmds = self.get_meson_log_compiler_checks() |
| for cmd in cmds: |
| if cmd[0] == 'ccache': |
| cmd = cmd[1:] |
| # Verify that -I flags from the `args` kwarg are first |
| # This is set in the '36 has function' test case |
| self.assertEqual(cmd[1], '-I/tmp') |
| # Verify that -O3 set via the environment is overridden by -O0 |
| Oargs = [arg for arg in cmd if arg.startswith('-O')] |
| self.assertEqual(Oargs, [Oflag, '-O0']) |
| |
| def _test_stds_impl(self, testdir: str, compiler: 'Compiler') -> None: |
| has_cpp17 = (compiler.get_id() not in {'clang', 'gcc'} or |
| compiler.get_id() == 'clang' and _clang_at_least(compiler, '>=5.0.0', '>=9.1') or |
| compiler.get_id() == 'gcc' and version_compare(compiler.version, '>=5.0.0')) |
| has_cpp2a_c17 = (compiler.get_id() not in {'clang', 'gcc'} or |
| compiler.get_id() == 'clang' and _clang_at_least(compiler, '>=6.0.0', '>=10.0') or |
| compiler.get_id() == 'gcc' and version_compare(compiler.version, '>=8.0.0')) |
| has_cpp20 = (compiler.get_id() not in {'clang', 'gcc'} or |
| compiler.get_id() == 'clang' and _clang_at_least(compiler, '>=10.0.0', None) or |
| compiler.get_id() == 'gcc' and version_compare(compiler.version, '>=10.0.0')) |
| has_cpp2b = (compiler.get_id() not in {'clang', 'gcc'} or |
| compiler.get_id() == 'clang' and _clang_at_least(compiler, '>=12.0.0', None) or |
| compiler.get_id() == 'gcc' and version_compare(compiler.version, '>=11.0.0')) |
| has_cpp23 = (compiler.get_id() not in {'clang', 'gcc'} or |
| compiler.get_id() == 'clang' and _clang_at_least(compiler, '>=17.0.0', None) or |
| compiler.get_id() == 'gcc' and version_compare(compiler.version, '>=11.0.0')) |
| has_cpp26 = (compiler.get_id() not in {'clang', 'gcc'} or |
| compiler.get_id() == 'clang' and _clang_at_least(compiler, '>=17.0.0', None) or |
| compiler.get_id() == 'gcc' and version_compare(compiler.version, '>=14.0.0')) |
| has_c18 = (compiler.get_id() not in {'clang', 'gcc'} or |
| compiler.get_id() == 'clang' and _clang_at_least(compiler, '>=8.0.0', '>=11.0') or |
| compiler.get_id() == 'gcc' and version_compare(compiler.version, '>=8.0.0')) |
| # Check that all the listed -std=xxx options for this compiler work just fine when used |
| # https://en.wikipedia.org/wiki/Xcode#Latest_versions |
| # https://www.gnu.org/software/gcc/projects/cxx-status.html |
| key = OptionKey('std', lang=compiler.language) |
| for v in compiler.get_options()[key].choices: |
| # we do it like this to handle gnu++17,c++17 and gnu17,c17 cleanly |
| # thus, C++ first |
| if '++17' in v and not has_cpp17: |
| continue |
| elif '++2a' in v and not has_cpp2a_c17: # https://en.cppreference.com/w/cpp/compiler_support |
| continue |
| elif '++20' in v and not has_cpp20: |
| continue |
| elif '++2b' in v and not has_cpp2b: |
| continue |
| elif '++23' in v and not has_cpp23: |
| continue |
| elif ('++26' in v or '++2c' in v) and not has_cpp26: |
| continue |
| # now C |
| elif '17' in v and not has_cpp2a_c17: |
| continue |
| elif '18' in v and not has_c18: |
| continue |
| self.init(testdir, extra_args=[f'-D{key!s}={v}']) |
| cmd = self.get_compdb()[0]['command'] |
| # c++03 and gnu++03 are not understood by ICC, don't try to look for them |
| skiplist = frozenset([ |
| ('intel', 'c++03'), |
| ('intel', 'gnu++03')]) |
| if v != 'none' and not (compiler.get_id(), v) in skiplist: |
| cmd_std = f" -std={v} " |
| self.assertIn(cmd_std, cmd) |
| try: |
| self.build() |
| except Exception: |
| print(f'{key!s} was {v!r}') |
| raise |
| self.wipe() |
| # Check that an invalid std option in CFLAGS/CPPFLAGS fails |
| # Needed because by default ICC ignores invalid options |
| cmd_std = '-std=FAIL' |
| if compiler.language == 'c': |
| env_flag_name = 'CFLAGS' |
| elif compiler.language == 'cpp': |
| env_flag_name = 'CXXFLAGS' |
| else: |
| raise NotImplementedError(f'Language {compiler.language} not defined.') |
| env = {} |
| env[env_flag_name] = cmd_std |
| with self.assertRaises((subprocess.CalledProcessError, EnvironmentException), |
| msg='C compiler should have failed with -std=FAIL'): |
| self.init(testdir, override_envvars = env) |
| # ICC won't fail in the above because additional flags are needed to |
| # make unknown -std=... options errors. |
| self.build() |
| |
| def test_compiler_c_stds(self): |
| ''' |
| Test that C stds specified for this compiler can all be used. Can't be |
| an ordinary test because it requires passing options to meson. |
| ''' |
| testdir = os.path.join(self.common_test_dir, '1 trivial') |
| env = get_fake_env(testdir, self.builddir, self.prefix) |
| cc = detect_c_compiler(env, MachineChoice.HOST) |
| self._test_stds_impl(testdir, cc) |
| |
| def test_compiler_cpp_stds(self): |
| ''' |
| Test that C++ stds specified for this compiler can all be used. Can't |
| be an ordinary test because it requires passing options to meson. |
| ''' |
| testdir = os.path.join(self.common_test_dir, '2 cpp') |
| env = get_fake_env(testdir, self.builddir, self.prefix) |
| cpp = detect_cpp_compiler(env, MachineChoice.HOST) |
| self._test_stds_impl(testdir, cpp) |
| |
| def test_unity_subproj(self): |
| testdir = os.path.join(self.common_test_dir, '42 subproject') |
| self.init(testdir, extra_args='--unity=subprojects') |
| pdirs = glob(os.path.join(self.builddir, 'subprojects/sublib/simpletest*.p')) |
| self.assertEqual(len(pdirs), 1) |
| self.assertPathExists(os.path.join(pdirs[0], 'simpletest-unity0.c')) |
| sdirs = glob(os.path.join(self.builddir, 'subprojects/sublib/*sublib*.p')) |
| self.assertEqual(len(sdirs), 1) |
| self.assertPathExists(os.path.join(sdirs[0], 'sublib-unity0.c')) |
| self.assertPathDoesNotExist(os.path.join(self.builddir, 'user@exe/user-unity.c')) |
| self.build() |
| |
| def test_installed_modes(self): |
| ''' |
| Test that files installed by these tests have the correct permissions. |
| Can't be an ordinary test because our installed_files.txt is very basic. |
| ''' |
| if is_cygwin(): |
| self.new_builddir_in_tempdir() |
| # Test file modes |
| testdir = os.path.join(self.common_test_dir, '12 data') |
| self.init(testdir) |
| self.install() |
| |
| f = os.path.join(self.installdir, 'etc', 'etcfile.dat') |
| found_mode = stat.filemode(os.stat(f).st_mode) |
| want_mode = 'rw-------' |
| self.assertEqual(want_mode, found_mode[1:]) |
| |
| f = os.path.join(self.installdir, 'usr', 'bin', 'runscript.sh') |
| statf = os.stat(f) |
| found_mode = stat.filemode(statf.st_mode) |
| want_mode = 'rwxr-sr-x' |
| self.assertEqual(want_mode, found_mode[1:]) |
| if os.getuid() == 0: |
| # The chown failed nonfatally if we're not root |
| self.assertEqual(0, statf.st_uid) |
| self.assertEqual(0, statf.st_gid) |
| |
| f = os.path.join(self.installdir, 'usr', 'share', 'progname', |
| 'fileobject_datafile.dat') |
| orig = os.path.join(testdir, 'fileobject_datafile.dat') |
| statf = os.stat(f) |
| statorig = os.stat(orig) |
| found_mode = stat.filemode(statf.st_mode) |
| orig_mode = stat.filemode(statorig.st_mode) |
| self.assertEqual(orig_mode[1:], found_mode[1:]) |
| self.assertEqual(os.getuid(), statf.st_uid) |
| if os.getuid() == 0: |
| # The chown failed nonfatally if we're not root |
| self.assertEqual(0, statf.st_gid) |
| |
| self.wipe() |
| # Test directory modes |
| testdir = os.path.join(self.common_test_dir, '59 install subdir') |
| self.init(testdir) |
| self.install() |
| |
| f = os.path.join(self.installdir, 'usr', 'share', 'sub1', 'second.dat') |
| statf = os.stat(f) |
| found_mode = stat.filemode(statf.st_mode) |
| want_mode = 'rwxr-x--x' |
| self.assertEqual(want_mode, found_mode[1:]) |
| if os.getuid() == 0: |
| # The chown failed nonfatally if we're not root |
| self.assertEqual(0, statf.st_uid) |
| |
| def test_installed_modes_extended(self): |
| ''' |
| Test that files are installed with correct permissions using install_mode. |
| ''' |
| if is_cygwin(): |
| self.new_builddir_in_tempdir() |
| testdir = os.path.join(self.common_test_dir, '190 install_mode') |
| self.init(testdir) |
| self.build() |
| self.install() |
| |
| for fsobj, want_mode in [ |
| ('bin', 'drwxr-x---'), |
| ('bin/runscript.sh', '-rwxr-sr-x'), |
| ('bin/trivialprog', '-rwxr-sr-x'), |
| ('include', 'drwxr-x---'), |
| ('include/config.h', '-rw-rwSr--'), |
| ('include/rootdir.h', '-r--r--r--'), |
| ('lib', 'drwxr-x---'), |
| ('lib/libstat.a', '-rw---Sr--'), |
| ('share', 'drwxr-x---'), |
| ('share/man', 'drwxr-x---'), |
| ('share/man/man1', 'drwxr-x---'), |
| ('share/man/man1/foo.1', '-r--r--r--'), |
| ('share/sub1', 'drwxr-x---'), |
| ('share/sub1/second.dat', '-rwxr-x--x'), |
| ('subdir', 'drwxr-x---'), |
| ('subdir/data.dat', '-rw-rwSr--'), |
| ]: |
| f = os.path.join(self.installdir, 'usr', *fsobj.split('/')) |
| found_mode = stat.filemode(os.stat(f).st_mode) |
| self.assertEqual(want_mode, found_mode, |
| msg=('Expected file %s to have mode %s but found %s instead.' % |
| (fsobj, want_mode, found_mode))) |
| # Ensure that introspect --installed works on all types of files |
| # FIXME: also verify the files list |
| self.introspect('--installed') |
| |
| def test_install_umask(self): |
| ''' |
| Test that files are installed with correct permissions using default |
| install umask of 022, regardless of the umask at time the worktree |
| was checked out or the build was executed. |
| ''' |
| if is_cygwin(): |
| self.new_builddir_in_tempdir() |
| # Copy source tree to a temporary directory and change permissions |
| # there to simulate a checkout with umask 002. |
| orig_testdir = os.path.join(self.unit_test_dir, '26 install umask') |
| # Create a new testdir under tmpdir. |
| tmpdir = os.path.realpath(tempfile.mkdtemp()) |
| self.addCleanup(windows_proof_rmtree, tmpdir) |
| testdir = os.path.join(tmpdir, '26 install umask') |
| # Copy the tree using shutil.copyfile, which will use the current umask |
| # instead of preserving permissions of the old tree. |
| save_umask = os.umask(0o002) |
| self.addCleanup(os.umask, save_umask) |
| shutil.copytree(orig_testdir, testdir, copy_function=shutil.copyfile) |
| # Preserve the executable status of subdir/sayhello though. |
| os.chmod(os.path.join(testdir, 'subdir', 'sayhello'), 0o775) |
| self.init(testdir) |
| # Run the build under a 027 umask now. |
| os.umask(0o027) |
| self.build() |
| # And keep umask 027 for the install step too. |
| self.install() |
| |
| for executable in [ |
| 'bin/prog', |
| 'share/subdir/sayhello', |
| ]: |
| f = os.path.join(self.installdir, 'usr', *executable.split('/')) |
| found_mode = stat.filemode(os.stat(f).st_mode) |
| want_mode = '-rwxr-xr-x' |
| self.assertEqual(want_mode, found_mode, |
| msg=('Expected file %s to have mode %s but found %s instead.' % |
| (executable, want_mode, found_mode))) |
| |
| for directory in [ |
| 'usr', |
| 'usr/bin', |
| 'usr/include', |
| 'usr/share', |
| 'usr/share/man', |
| 'usr/share/man/man1', |
| 'usr/share/subdir', |
| ]: |
| f = os.path.join(self.installdir, *directory.split('/')) |
| found_mode = stat.filemode(os.stat(f).st_mode) |
| want_mode = 'drwxr-xr-x' |
| self.assertEqual(want_mode, found_mode, |
| msg=('Expected directory %s to have mode %s but found %s instead.' % |
| (directory, want_mode, found_mode))) |
| |
| for datafile in [ |
| 'include/sample.h', |
| 'share/datafile.cat', |
| 'share/file.dat', |
| 'share/man/man1/prog.1', |
| 'share/subdir/datafile.dog', |
| ]: |
| f = os.path.join(self.installdir, 'usr', *datafile.split('/')) |
| found_mode = stat.filemode(os.stat(f).st_mode) |
| want_mode = '-rw-r--r--' |
| self.assertEqual(want_mode, found_mode, |
| msg=('Expected file %s to have mode %s but found %s instead.' % |
| (datafile, want_mode, found_mode))) |
| |
| def test_cpp_std_override(self): |
| testdir = os.path.join(self.unit_test_dir, '6 std override') |
| self.init(testdir) |
| compdb = self.get_compdb() |
| # Don't try to use -std=c++03 as a check for the |
| # presence of a compiler flag, as ICC does not |
| # support it. |
| for i in compdb: |
| if 'prog98' in i['file']: |
| c98_comp = i['command'] |
| if 'prog11' in i['file']: |
| c11_comp = i['command'] |
| if 'progp' in i['file']: |
| plain_comp = i['command'] |
| self.assertNotEqual(len(plain_comp), 0) |
| self.assertIn('-std=c++98', c98_comp) |
| self.assertNotIn('-std=c++11', c98_comp) |
| self.assertIn('-std=c++11', c11_comp) |
| self.assertNotIn('-std=c++98', c11_comp) |
| self.assertNotIn('-std=c++98', plain_comp) |
| self.assertNotIn('-std=c++11', plain_comp) |
| # Now werror |
| self.assertIn('-Werror', plain_comp) |
| self.assertNotIn('-Werror', c98_comp) |
| |
| def test_run_installed(self): |
| if is_cygwin() or is_osx(): |
| raise SkipTest('LD_LIBRARY_PATH and RPATH not applicable') |
| |
| testdir = os.path.join(self.unit_test_dir, '7 run installed') |
| self.init(testdir) |
| self.build() |
| self.install() |
| installed_exe = os.path.join(self.installdir, 'usr/bin/prog') |
| installed_libdir = os.path.join(self.installdir, 'usr/foo') |
| installed_lib = os.path.join(installed_libdir, 'libfoo.so') |
| self.assertTrue(os.path.isfile(installed_exe)) |
| self.assertTrue(os.path.isdir(installed_libdir)) |
| self.assertTrue(os.path.isfile(installed_lib)) |
| # Must fail when run without LD_LIBRARY_PATH to ensure that |
| # rpath has been properly stripped rather than pointing to the builddir. |
| self.assertNotEqual(subprocess.call(installed_exe, stderr=subprocess.DEVNULL), 0) |
| # When LD_LIBRARY_PATH is set it should start working. |
| # For some reason setting LD_LIBRARY_PATH in os.environ fails |
| # when all tests are run (but works when only this test is run), |
| # but doing this explicitly works. |
| env = os.environ.copy() |
| env['LD_LIBRARY_PATH'] = ':'.join([installed_libdir, env.get('LD_LIBRARY_PATH', '')]) |
| self.assertEqual(subprocess.call(installed_exe, env=env), 0) |
| # Ensure that introspect --installed works |
| installed = self.introspect('--installed') |
| for v in installed.values(): |
| self.assertTrue('prog' in v or 'foo' in v) |
| |
| @skipIfNoPkgconfig |
| def test_order_of_l_arguments(self): |
| testdir = os.path.join(self.unit_test_dir, '8 -L -l order') |
| self.init(testdir, override_envvars={'PKG_CONFIG_PATH': testdir}) |
| # NOTE: .pc file has -Lfoo -lfoo -Lbar -lbar but pkg-config reorders |
| # the flags before returning them to -Lfoo -Lbar -lfoo -lbar |
| # but pkgconf seems to not do that. Sigh. Support both. |
| expected_order = [('-L/me/first', '-lfoo1'), |
| ('-L/me/second', '-lfoo2'), |
| ('-L/me/first', '-L/me/second'), |
| ('-lfoo1', '-lfoo2'), |
| ('-L/me/second', '-L/me/third'), |
| ('-L/me/third', '-L/me/fourth',), |
| ('-L/me/third', '-lfoo3'), |
| ('-L/me/fourth', '-lfoo4'), |
| ('-lfoo3', '-lfoo4'), |
| ] |
| with open(os.path.join(self.builddir, 'build.ninja'), encoding='utf-8') as ifile: |
| for line in ifile: |
| if expected_order[0][0] in line: |
| for first, second in expected_order: |
| self.assertLess(line.index(first), line.index(second)) |
| return |
| raise RuntimeError('Linker entries not found in the Ninja file.') |
| |
| def test_introspect_dependencies(self): |
| ''' |
| Tests that mesonintrospect --dependencies returns expected output. |
| ''' |
| testdir = os.path.join(self.framework_test_dir, '7 gnome') |
| self.init(testdir) |
| glib_found = False |
| gobject_found = False |
| deps = self.introspect('--dependencies') |
| self.assertIsInstance(deps, list) |
| for dep in deps: |
| self.assertIsInstance(dep, dict) |
| self.assertIn('name', dep) |
| self.assertIn('compile_args', dep) |
| self.assertIn('link_args', dep) |
| if dep['name'] == 'glib-2.0': |
| glib_found = True |
| elif dep['name'] == 'gobject-2.0': |
| gobject_found = True |
| self.assertTrue(glib_found) |
| self.assertTrue(gobject_found) |
| if subprocess.call([PKG_CONFIG, '--exists', 'glib-2.0 >= 2.56.2']) != 0: |
| raise SkipTest('glib >= 2.56.2 needed for the rest') |
| targets = self.introspect('--targets') |
| docbook_target = None |
| for t in targets: |
| if t['name'] == 'generated-gdbus-docbook': |
| docbook_target = t |
| break |
| self.assertIsInstance(docbook_target, dict) |
| self.assertEqual(os.path.basename(t['filename'][0]), 'generated-gdbus-doc-' + os.path.basename(t['target_sources'][0]['sources'][0])) |
| |
| def test_introspect_installed(self): |
| testdir = os.path.join(self.linuxlike_test_dir, '7 library versions') |
| self.init(testdir) |
| |
| install = self.introspect('--installed') |
| install = {os.path.basename(k): v for k, v in install.items()} |
| print(install) |
| if is_osx(): |
| the_truth = { |
| 'libmodule.dylib': '/usr/lib/libmodule.dylib', |
| 'libnoversion.dylib': '/usr/lib/libnoversion.dylib', |
| 'libonlysoversion.5.dylib': '/usr/lib/libonlysoversion.5.dylib', |
| 'libonlysoversion.dylib': '/usr/lib/libonlysoversion.dylib', |
| 'libonlyversion.1.dylib': '/usr/lib/libonlyversion.1.dylib', |
| 'libonlyversion.dylib': '/usr/lib/libonlyversion.dylib', |
| 'libsome.0.dylib': '/usr/lib/libsome.0.dylib', |
| 'libsome.dylib': '/usr/lib/libsome.dylib', |
| } |
| the_truth_2 = {'/usr/lib/libsome.dylib', |
| '/usr/lib/libsome.0.dylib', |
| } |
| else: |
| the_truth = { |
| 'libmodule.so': '/usr/lib/libmodule.so', |
| 'libnoversion.so': '/usr/lib/libnoversion.so', |
| 'libonlysoversion.so': '/usr/lib/libonlysoversion.so', |
| 'libonlysoversion.so.5': '/usr/lib/libonlysoversion.so.5', |
| 'libonlyversion.so': '/usr/lib/libonlyversion.so', |
| 'libonlyversion.so.1': '/usr/lib/libonlyversion.so.1', |
| 'libonlyversion.so.1.4.5': '/usr/lib/libonlyversion.so.1.4.5', |
| 'libsome.so': '/usr/lib/libsome.so', |
| 'libsome.so.0': '/usr/lib/libsome.so.0', |
| 'libsome.so.1.2.3': '/usr/lib/libsome.so.1.2.3', |
| } |
| the_truth_2 = {'/usr/lib/libsome.so', |
| '/usr/lib/libsome.so.0', |
| '/usr/lib/libsome.so.1.2.3'} |
| self.assertDictEqual(install, the_truth) |
| |
| targets = self.introspect('--targets') |
| for t in targets: |
| if t['name'] != 'some': |
| continue |
| self.assertSetEqual(the_truth_2, set(t['install_filename'])) |
| |
| def test_build_rpath(self): |
| if is_cygwin(): |
| raise SkipTest('Windows PE/COFF binaries do not use RPATH') |
| testdir = os.path.join(self.unit_test_dir, '10 build_rpath') |
| self.init(testdir) |
| self.build() |
| build_rpath = get_rpath(os.path.join(self.builddir, 'prog')) |
| self.assertEqual(build_rpath, '$ORIGIN/sub:/foo/bar') |
| build_rpath = get_rpath(os.path.join(self.builddir, 'progcxx')) |
| self.assertEqual(build_rpath, '$ORIGIN/sub:/foo/bar') |
| self.install() |
| install_rpath = get_rpath(os.path.join(self.installdir, 'usr/bin/prog')) |
| self.assertEqual(install_rpath, '/baz') |
| install_rpath = get_rpath(os.path.join(self.installdir, 'usr/bin/progcxx')) |
| self.assertEqual(install_rpath, 'baz') |
| |
| @skipIfNoPkgconfig |
| def test_build_rpath_pkgconfig(self): |
| ''' |
| Test that current build artefacts (libs) are found first on the rpath, |
| manually specified rpath comes second and additional rpath elements (from |
| pkg-config files) come last |
| ''' |
| if is_cygwin(): |
| raise SkipTest('Windows PE/COFF binaries do not use RPATH') |
| testdir = os.path.join(self.unit_test_dir, '89 pkgconfig build rpath order') |
| self.init(testdir, override_envvars={'PKG_CONFIG_PATH': testdir}) |
| self.build() |
| build_rpath = get_rpath(os.path.join(self.builddir, 'prog')) |
| self.assertEqual(build_rpath, '$ORIGIN/sub:/foo/bar:/foo/dummy') |
| build_rpath = get_rpath(os.path.join(self.builddir, 'progcxx')) |
| self.assertEqual(build_rpath, '$ORIGIN/sub:/foo/bar:/foo/dummy') |
| self.install() |
| install_rpath = get_rpath(os.path.join(self.installdir, 'usr/bin/prog')) |
| self.assertEqual(install_rpath, '/baz:/foo/dummy') |
| install_rpath = get_rpath(os.path.join(self.installdir, 'usr/bin/progcxx')) |
| self.assertEqual(install_rpath, 'baz:/foo/dummy') |
| |
| def test_global_rpath(self): |
| if is_cygwin(): |
| raise SkipTest('Windows PE/COFF binaries do not use RPATH') |
| if is_osx(): |
| raise SkipTest('Global RPATHs via LDFLAGS not yet supported on MacOS (does anybody need it?)') |
| |
| testdir = os.path.join(self.unit_test_dir, '79 global-rpath') |
| oldinstalldir = self.installdir |
| |
| # Build and install an external library without DESTDIR. |
| # The external library generates a .pc file without an rpath. |
| yonder_dir = os.path.join(testdir, 'yonder') |
| yonder_prefix = os.path.join(oldinstalldir, 'yonder') |
| yonder_libdir = os.path.join(yonder_prefix, self.libdir) |
| self.prefix = yonder_prefix |
| self.installdir = yonder_prefix |
| self.init(yonder_dir) |
| self.build() |
| self.install(use_destdir=False) |
| |
| # Since rpath has multiple valid formats we need to |
| # test that they are all properly used. |
| rpath_formats = [ |
| ('-Wl,-rpath=', False), |
| ('-Wl,-rpath,', False), |
| ('-Wl,--just-symbols=', True), |
| ('-Wl,--just-symbols,', True), |
| ('-Wl,-R', False), |
| ('-Wl,-R,', False) |
| ] |
| for rpath_format, exception in rpath_formats: |
| # Build an app that uses that installed library. |
| # Supply the rpath to the installed library via LDFLAGS |
| # (as systems like buildroot and guix are wont to do) |
| # and verify install preserves that rpath. |
| self.new_builddir() |
| env = {'LDFLAGS': rpath_format + yonder_libdir, |
| 'PKG_CONFIG_PATH': os.path.join(yonder_libdir, 'pkgconfig')} |
| if exception: |
| with self.assertRaises(subprocess.CalledProcessError): |
| self.init(testdir, override_envvars=env) |
| continue |
| self.init(testdir, override_envvars=env) |
| self.build() |
| self.install(use_destdir=False) |
| got_rpath = get_rpath(os.path.join(yonder_prefix, 'bin/rpathified')) |
| self.assertEqual(got_rpath, yonder_libdir, rpath_format) |
| |
| @skip_if_not_base_option('b_sanitize') |
| def test_pch_with_address_sanitizer(self): |
| if is_cygwin(): |
| raise SkipTest('asan not available on Cygwin') |
| if is_openbsd(): |
| raise SkipTest('-fsanitize=address is not supported on OpenBSD') |
| |
| testdir = os.path.join(self.common_test_dir, '13 pch') |
| self.init(testdir, extra_args=['-Db_sanitize=address', '-Db_lundef=false']) |
| self.build() |
| compdb = self.get_compdb() |
| for i in compdb: |
| self.assertIn("-fsanitize=address", i["command"]) |
| |
| def test_cross_find_program(self): |
| testdir = os.path.join(self.unit_test_dir, '11 cross prog') |
| crossfile = tempfile.NamedTemporaryFile(mode='w', encoding='utf-8') |
| print(os.path.join(testdir, 'some_cross_tool.py')) |
| |
| tool_path = os.path.join(testdir, 'some_cross_tool.py') |
| |
| crossfile.write(textwrap.dedent(f'''\ |
| [binaries] |
| c = '{shutil.which('gcc' if is_sunos() else 'cc')}' |
| ar = '{shutil.which('ar')}' |
| strip = '{shutil.which('strip')}' |
| sometool.py = ['{tool_path}'] |
| someothertool.py = '{tool_path}' |
| |
| [properties] |
| |
| [host_machine] |
| system = 'linux' |
| cpu_family = 'arm' |
| cpu = 'armv7' # Not sure if correct. |
| endian = 'little' |
| ''')) |
| crossfile.flush() |
| self.meson_cross_files = [crossfile.name] |
| self.init(testdir) |
| |
| def test_reconfigure(self): |
| testdir = os.path.join(self.unit_test_dir, '13 reconfigure') |
| self.init(testdir, extra_args=['-Db_coverage=true'], default_args=False) |
| self.build('reconfigure') |
| |
| def test_vala_generated_source_buildir_inside_source_tree(self): |
| ''' |
| Test that valac outputs generated C files in the expected location when |
| the builddir is a subdir of the source tree. |
| ''' |
| if not shutil.which('valac'): |
| raise SkipTest('valac not installed.') |
| |
| testdir = os.path.join(self.vala_test_dir, '8 generated sources') |
| newdir = os.path.join(self.builddir, 'srctree') |
| shutil.copytree(testdir, newdir) |
| testdir = newdir |
| # New builddir |
| builddir = os.path.join(testdir, 'subdir/_build') |
| os.makedirs(builddir, exist_ok=True) |
| self.change_builddir(builddir) |
| self.init(testdir) |
| self.build() |
| |
| def test_old_gnome_module_codepaths(self): |
| ''' |
| A lot of code in the GNOME module is conditional on the version of the |
| glib tools that are installed, and breakages in the old code can slip |
| by once the CI has a newer glib version. So we force the GNOME module |
| to pretend that it's running on an ancient glib so the fallback code is |
| also tested. |
| ''' |
| testdir = os.path.join(self.framework_test_dir, '7 gnome') |
| with mock.patch('mesonbuild.modules.gnome.GnomeModule._get_native_glib_version', mock.Mock(return_value='2.20')): |
| env = {'MESON_UNIT_TEST_PRETEND_GLIB_OLD': "1"} |
| self.init(testdir, |
| inprocess=True, |
| override_envvars=env) |
| self.build(override_envvars=env) |
| |
| @skipIfNoPkgconfig |
| def test_pkgconfig_usage(self): |
| testdir1 = os.path.join(self.unit_test_dir, '27 pkgconfig usage/dependency') |
| testdir2 = os.path.join(self.unit_test_dir, '27 pkgconfig usage/dependee') |
| if subprocess.call([PKG_CONFIG, '--cflags', 'glib-2.0'], |
| stdout=subprocess.DEVNULL, |
| stderr=subprocess.DEVNULL) != 0: |
| raise SkipTest('Glib 2.0 dependency not available.') |
| with tempfile.TemporaryDirectory() as tempdirname: |
| self.init(testdir1, extra_args=['--prefix=' + tempdirname, '--libdir=lib'], default_args=False) |
| self.install(use_destdir=False) |
| shutil.rmtree(self.builddir) |
| os.mkdir(self.builddir) |
| pkg_dir = os.path.join(tempdirname, 'lib/pkgconfig') |
| self.assertTrue(os.path.exists(os.path.join(pkg_dir, 'libpkgdep.pc'))) |
| lib_dir = os.path.join(tempdirname, 'lib') |
| myenv = os.environ.copy() |
| myenv['PKG_CONFIG_PATH'] = pkg_dir |
| # Private internal libraries must not leak out. |
| pkg_out = subprocess.check_output([PKG_CONFIG, '--static', '--libs', 'libpkgdep'], env=myenv) |
| self.assertNotIn(b'libpkgdep-int', pkg_out, 'Internal library leaked out.') |
| # Dependencies must not leak to cflags when building only a shared library. |
| pkg_out = subprocess.check_output([PKG_CONFIG, '--cflags', 'libpkgdep'], env=myenv) |
| self.assertNotIn(b'glib', pkg_out, 'Internal dependency leaked to headers.') |
| # Test that the result is usable. |
| self.init(testdir2, override_envvars=myenv) |
| self.build(override_envvars=myenv) |
| myenv = os.environ.copy() |
| myenv['LD_LIBRARY_PATH'] = ':'.join([lib_dir, myenv.get('LD_LIBRARY_PATH', '')]) |
| if is_cygwin(): |
| bin_dir = os.path.join(tempdirname, 'bin') |
| myenv['PATH'] = bin_dir + os.pathsep + myenv['PATH'] |
| self.assertTrue(os.path.isdir(lib_dir)) |
| test_exe = os.path.join(self.builddir, 'pkguser') |
| self.assertTrue(os.path.isfile(test_exe)) |
| subprocess.check_call(test_exe, env=myenv) |
| |
| @skipIfNoPkgconfig |
| def test_pkgconfig_relative_paths(self): |
| testdir = os.path.join(self.unit_test_dir, '61 pkgconfig relative paths') |
| pkg_dir = os.path.join(testdir, 'pkgconfig') |
| self.assertPathExists(os.path.join(pkg_dir, 'librelativepath.pc')) |
| |
| env = get_fake_env(testdir, self.builddir, self.prefix) |
| env.coredata.set_options({OptionKey('pkg_config_path'): pkg_dir}, subproject='') |
| kwargs = {'required': True, 'silent': True} |
| relative_path_dep = PkgConfigDependency('librelativepath', env, kwargs) |
| self.assertTrue(relative_path_dep.found()) |
| |
| # Ensure link_args are properly quoted |
| libpath = Path(self.builddir) / '../relativepath/lib' |
| link_args = ['-L' + libpath.as_posix(), '-lrelativepath'] |
| self.assertEqual(relative_path_dep.get_link_args(), link_args) |
| |
| @skipIfNoPkgconfig |
| def test_pkgconfig_duplicate_path_entries(self): |
| testdir = os.path.join(self.unit_test_dir, '111 pkgconfig duplicate path entries') |
| pkg_dir = os.path.join(testdir, 'pkgconfig') |
| |
| env = get_fake_env(testdir, self.builddir, self.prefix) |
| env.coredata.set_options({OptionKey('pkg_config_path'): pkg_dir}, subproject='') |
| |
| # Regression test: This used to modify the value of `pkg_config_path` |
| # option, adding the meson-uninstalled directory to it. |
| PkgConfigInterface.setup_env({}, env, MachineChoice.HOST, uninstalled=True) |
| |
| pkg_config_path = env.coredata.options[OptionKey('pkg_config_path')].value |
| self.assertEqual(pkg_config_path, [pkg_dir]) |
| |
| @skipIfNoPkgconfig |
| def test_pkgconfig_internal_libraries(self): |
| ''' |
| ''' |
| with tempfile.TemporaryDirectory() as tempdirname: |
| # build library |
| testdirbase = os.path.join(self.unit_test_dir, '32 pkgconfig use libraries') |
| testdirlib = os.path.join(testdirbase, 'lib') |
| self.init(testdirlib, extra_args=['--prefix=' + tempdirname, |
| '--libdir=lib', |
| '--default-library=static'], default_args=False) |
| self.build() |
| self.install(use_destdir=False) |
| |
| # build user of library |
| pkg_dir = os.path.join(tempdirname, 'lib/pkgconfig') |
| self.new_builddir() |
| self.init(os.path.join(testdirbase, 'app'), |
| override_envvars={'PKG_CONFIG_PATH': pkg_dir}) |
| self.build() |
| |
| @skipIfNoPkgconfig |
| def test_static_archive_stripping(self): |
| ''' |
| Check that Meson produces valid static archives with --strip enabled |
| ''' |
| with tempfile.TemporaryDirectory() as tempdirname: |
| testdirbase = os.path.join(self.unit_test_dir, '65 static archive stripping') |
| |
| # build lib |
| self.new_builddir() |
| testdirlib = os.path.join(testdirbase, 'lib') |
| testlibprefix = os.path.join(tempdirname, 'libprefix') |
| self.init(testdirlib, extra_args=['--prefix=' + testlibprefix, |
| '--libdir=lib', |
| '--default-library=static', |
| '--buildtype=debug', |
| '--strip'], default_args=False) |
| self.build() |
| self.install(use_destdir=False) |
| |
| # build executable (uses lib, fails if static archive has been stripped incorrectly) |
| pkg_dir = os.path.join(testlibprefix, 'lib/pkgconfig') |
| self.new_builddir() |
| self.init(os.path.join(testdirbase, 'app'), |
| override_envvars={'PKG_CONFIG_PATH': pkg_dir}) |
| self.build() |
| |
| @skipIfNoPkgconfig |
| def test_pkgconfig_formatting(self): |
| testdir = os.path.join(self.unit_test_dir, '38 pkgconfig format') |
| self.init(testdir) |
| myenv = os.environ.copy() |
| myenv['PKG_CONFIG_PATH'] = _prepend_pkg_config_path(self.privatedir) |
| stdo = subprocess.check_output([PKG_CONFIG, '--libs-only-l', 'libsomething'], env=myenv) |
| deps = [b'-lgobject-2.0', b'-lgio-2.0', b'-lglib-2.0', b'-lsomething'] |
| if is_windows() or is_cygwin() or is_osx() or is_openbsd(): |
| # On Windows, libintl is a separate library |
| deps.append(b'-lintl') |
| self.assertEqual(set(deps), set(stdo.split())) |
| |
| @skipIfNoPkgconfig |
| @skip_if_not_language('cs') |
| def test_pkgconfig_csharp_library(self): |
| testdir = os.path.join(self.unit_test_dir, '49 pkgconfig csharp library') |
| self.init(testdir) |
| myenv = os.environ.copy() |
| myenv['PKG_CONFIG_PATH'] = _prepend_pkg_config_path(self.privatedir) |
| stdo = subprocess.check_output([PKG_CONFIG, '--libs', 'libsomething'], env=myenv) |
| |
| self.assertEqual("-r/usr/lib/libsomething.dll", str(stdo.decode('ascii')).strip()) |
| |
| @skipIfNoPkgconfig |
| def test_pkgconfig_link_order(self): |
| ''' |
| Test that libraries are listed before their dependencies. |
| ''' |
| testdir = os.path.join(self.unit_test_dir, '52 pkgconfig static link order') |
| self.init(testdir) |
| myenv = os.environ.copy() |
| myenv['PKG_CONFIG_PATH'] = _prepend_pkg_config_path(self.privatedir) |
| stdo = subprocess.check_output([PKG_CONFIG, '--libs', 'libsomething'], env=myenv) |
| deps = stdo.split() |
| self.assertLess(deps.index(b'-lsomething'), deps.index(b'-ldependency')) |
| |
| def test_deterministic_dep_order(self): |
| ''' |
| Test that the dependencies are always listed in a deterministic order. |
| ''' |
| testdir = os.path.join(self.unit_test_dir, '42 dep order') |
| self.init(testdir) |
| with open(os.path.join(self.builddir, 'build.ninja'), encoding='utf-8') as bfile: |
| for line in bfile: |
| if 'build myexe:' in line or 'build myexe.exe:' in line: |
| self.assertIn('liblib1.a liblib2.a', line) |
| return |
| raise RuntimeError('Could not find the build rule') |
| |
| def test_deterministic_rpath_order(self): |
| ''' |
| Test that the rpaths are always listed in a deterministic order. |
| ''' |
| if is_cygwin(): |
| raise SkipTest('rpath are not used on Cygwin') |
| testdir = os.path.join(self.unit_test_dir, '41 rpath order') |
| self.init(testdir) |
| if is_osx(): |
| rpathre = re.compile(r'-rpath,.*/subprojects/sub1.*-rpath,.*/subprojects/sub2') |
| else: |
| rpathre = re.compile(r'-rpath,\$\$ORIGIN/subprojects/sub1:\$\$ORIGIN/subprojects/sub2') |
| with open(os.path.join(self.builddir, 'build.ninja'), encoding='utf-8') as bfile: |
| for line in bfile: |
| if '-rpath' in line: |
| self.assertRegex(line, rpathre) |
| return |
| raise RuntimeError('Could not find the rpath') |
| |
| def test_override_with_exe_dep(self): |
| ''' |
| Test that we produce the correct dependencies when a program is overridden with an executable. |
| ''' |
| testdir = os.path.join(self.src_root, 'test cases', 'native', '9 override with exe') |
| self.init(testdir) |
| with open(os.path.join(self.builddir, 'build.ninja'), encoding='utf-8') as bfile: |
| for line in bfile: |
| if 'main1.c:' in line or 'main2.c:' in line: |
| self.assertIn('| subprojects/sub/foobar', line) |
| |
| @skipIfNoPkgconfig |
| def test_usage_external_library(self): |
| ''' |
| Test that uninstalled usage of an external library (from the system or |
| PkgConfigDependency) works. On macOS, this workflow works out of the |
| box. On Linux, BSDs, Windows, etc, you need to set extra arguments such |
| as LD_LIBRARY_PATH, etc, so this test is skipped. |
| |
| The system library is found with cc.find_library() and pkg-config deps. |
| ''' |
| oldprefix = self.prefix |
| # Install external library so we can find it |
| testdir = os.path.join(self.unit_test_dir, '39 external, internal library rpath', 'external library') |
| # install into installdir without using DESTDIR |
| installdir = self.installdir |
| self.prefix = installdir |
| self.init(testdir) |
| self.prefix = oldprefix |
| self.build() |
| self.install(use_destdir=False) |
| ## New builddir for the consumer |
| self.new_builddir() |
| env = {'LIBRARY_PATH': os.path.join(installdir, self.libdir), |
| 'PKG_CONFIG_PATH': _prepend_pkg_config_path(os.path.join(installdir, self.libdir, 'pkgconfig'))} |
| testdir = os.path.join(self.unit_test_dir, '39 external, internal library rpath', 'built library') |
| # install into installdir without using DESTDIR |
| self.prefix = self.installdir |
| self.init(testdir, override_envvars=env) |
| self.prefix = oldprefix |
| self.build(override_envvars=env) |
| # test uninstalled |
| self.run_tests(override_envvars=env) |
| if not (is_osx() or is_linux()): |
| return |
| # test running after installation |
| self.install(use_destdir=False) |
| prog = os.path.join(self.installdir, 'bin', 'prog') |
| self._run([prog]) |
| if not is_osx(): |
| # Rest of the workflow only works on macOS |
| return |
| out = self._run(['otool', '-L', prog]) |
| self.assertNotIn('@rpath', out) |
| ## New builddir for testing that DESTDIR is not added to install_name |
| self.new_builddir() |
| # install into installdir with DESTDIR |
| self.init(testdir, override_envvars=env) |
| self.build(override_envvars=env) |
| # test running after installation |
| self.install(override_envvars=env) |
| prog = self.installdir + os.path.join(self.prefix, 'bin', 'prog') |
| lib = self.installdir + os.path.join(self.prefix, 'lib', 'libbar_built.dylib') |
| for f in prog, lib: |
| out = self._run(['otool', '-L', f]) |
| # Ensure that the otool output does not contain self.installdir |
| self.assertNotRegex(out, self.installdir + '.*dylib ') |
| |
| @skipIfNoPkgconfig |
| def test_link_arg_fullname(self): |
| ''' |
| Test for support of -l:libfullname.a |
| see: https://github.com/mesonbuild/meson/issues/9000 |
| https://stackoverflow.com/questions/48532868/gcc-library-option-with-a-colon-llibevent-a |
| ''' |
| testdir = os.path.join(self.unit_test_dir, '98 link full name','libtestprovider') |
| oldprefix = self.prefix |
| # install into installdir without using DESTDIR |
| installdir = self.installdir |
| self.prefix = installdir |
| self.init(testdir) |
| self.prefix=oldprefix |
| self.build() |
| self.install(use_destdir=False) |
| |
| self.new_builddir() |
| env = {'LIBRARY_PATH': os.path.join(installdir, self.libdir), |
| 'PKG_CONFIG_PATH': _prepend_pkg_config_path(os.path.join(installdir, self.libdir, 'pkgconfig'))} |
| testdir = os.path.join(self.unit_test_dir, '98 link full name','proguser') |
| self.init(testdir,override_envvars=env) |
| |
| # test for link with full path |
| with open(os.path.join(self.builddir, 'build.ninja'), encoding='utf-8') as bfile: |
| for line in bfile: |
| if 'build dprovidertest:' in line: |
| self.assertIn('/libtestprovider.a', line) |
| |
| if is_osx(): |
| # macOS's ld do not supports `--whole-archive`, skip build & run |
| return |
| |
| self.build(override_envvars=env) |
| |
| # skip test if pkg-config is too old. |
| # before v0.28, Libs flags like -Wl will not kept in context order with -l flags. |
| # see https://gitlab.freedesktop.org/pkg-config/pkg-config/-/blob/master/NEWS |
| pkgconfigver = subprocess.check_output([PKG_CONFIG, '--version']) |
| if b'0.28' > pkgconfigver: |
| raise SkipTest('pkg-config is too old to be correctly done this.') |
| self.run_tests() |
| |
| @skipIfNoPkgconfig |
| def test_usage_pkgconfig_prefixes(self): |
| ''' |
| Build and install two external libraries, to different prefixes, |
| then build and install a client program that finds them via pkgconfig, |
| and verify the installed client program runs. |
| ''' |
| oldinstalldir = self.installdir |
| |
| # Build and install both external libraries without DESTDIR |
| val1dir = os.path.join(self.unit_test_dir, '74 pkgconfig prefixes', 'val1') |
| val1prefix = os.path.join(oldinstalldir, 'val1') |
| self.prefix = val1prefix |
| self.installdir = val1prefix |
| self.init(val1dir) |
| self.build() |
| self.install(use_destdir=False) |
| self.new_builddir() |
| |
| env1 = {} |
| env1['PKG_CONFIG_PATH'] = os.path.join(val1prefix, self.libdir, 'pkgconfig') |
| val2dir = os.path.join(self.unit_test_dir, '74 pkgconfig prefixes', 'val2') |
| val2prefix = os.path.join(oldinstalldir, 'val2') |
| self.prefix = val2prefix |
| self.installdir = val2prefix |
| self.init(val2dir, override_envvars=env1) |
| self.build() |
| self.install(use_destdir=False) |
| self.new_builddir() |
| |
| # Build, install, and run the client program |
| env2 = {} |
| env2['PKG_CONFIG_PATH'] = os.path.join(val2prefix, self.libdir, 'pkgconfig') |
| testdir = os.path.join(self.unit_test_dir, '74 pkgconfig prefixes', 'client') |
| testprefix = os.path.join(oldinstalldir, 'client') |
| self.prefix = testprefix |
| self.installdir = testprefix |
| self.init(testdir, override_envvars=env2) |
| self.build() |
| self.install(use_destdir=False) |
| prog = os.path.join(self.installdir, 'bin', 'client') |
| env3 = {} |
| if is_cygwin(): |
| env3['PATH'] = os.path.join(val1prefix, 'bin') + \ |
| os.pathsep + \ |
| os.path.join(val2prefix, 'bin') + \ |
| os.pathsep + os.environ['PATH'] |
| out = self._run([prog], override_envvars=env3).strip() |
| # Expected output is val1 + val2 = 3 |
| self.assertEqual(out, '3') |
| |
| def install_subdir_invalid_symlinks(self, testdir, subdir_path): |
| ''' |
| Test that installation of broken symlinks works fine. |
| https://github.com/mesonbuild/meson/issues/3914 |
| ''' |
| testdir = os.path.join(self.common_test_dir, testdir) |
| subdir = os.path.join(testdir, subdir_path) |
| with chdir(subdir): |
| # Can't distribute broken symlinks in the source tree because it breaks |
| # the creation of zipapps. Create it dynamically and run the test by |
| # hand. |
| src = '../../nonexistent.txt' |
| os.symlink(src, 'invalid-symlink.txt') |
| try: |
| self.init(testdir) |
| self.build() |
| self.install() |
| install_path = subdir_path.split(os.path.sep)[-1] |
| link = os.path.join(self.installdir, 'usr', 'share', install_path, 'invalid-symlink.txt') |
| self.assertTrue(os.path.islink(link), msg=link) |
| self.assertEqual(src, os.readlink(link)) |
| self.assertFalse(os.path.isfile(link), msg=link) |
| finally: |
| os.remove(os.path.join(subdir, 'invalid-symlink.txt')) |
| |
| def test_install_subdir_symlinks(self): |
| self.install_subdir_invalid_symlinks('59 install subdir', os.path.join('sub', 'sub1')) |
| |
| def test_install_subdir_symlinks_with_default_umask(self): |
| self.install_subdir_invalid_symlinks('190 install_mode', 'sub2') |
| |
| def test_install_subdir_symlinks_with_default_umask_and_mode(self): |
| self.install_subdir_invalid_symlinks('190 install_mode', 'sub1') |
| |
| @skipIfNoPkgconfigDep('gmodule-2.0') |
| def test_ldflag_dedup(self): |
| testdir = os.path.join(self.unit_test_dir, '51 ldflagdedup') |
| if is_cygwin() or is_osx(): |
| raise SkipTest('Not applicable on Cygwin or OSX.') |
| env = get_fake_env() |
| cc = detect_c_compiler(env, MachineChoice.HOST) |
| linker = cc.linker |
| if not linker.export_dynamic_args(env): |
| raise SkipTest('Not applicable for linkers without --export-dynamic') |
| self.init(testdir) |
| build_ninja = os.path.join(self.builddir, 'build.ninja') |
| max_count = 0 |
| search_term = '-Wl,--export-dynamic' |
| with open(build_ninja, encoding='utf-8') as f: |
| for line in f: |
| max_count = max(max_count, line.count(search_term)) |
| self.assertEqual(max_count, 1, 'Export dynamic incorrectly deduplicated.') |
| |
| def test_compiler_libs_static_dedup(self): |
| testdir = os.path.join(self.unit_test_dir, '55 dedup compiler libs') |
| self.init(testdir) |
| build_ninja = os.path.join(self.builddir, 'build.ninja') |
| with open(build_ninja, encoding='utf-8') as f: |
| lines = f.readlines() |
| for lib in ('-ldl', '-lm', '-lc', '-lrt'): |
| for line in lines: |
| if lib not in line: |
| continue |
| # Assert that |
| self.assertEqual(len(line.split(lib)), 2, msg=(lib, line)) |
| |
| @skipIfNoPkgconfig |
| def test_noncross_options(self): |
| # C_std defined in project options must be in effect also when native compiling. |
| testdir = os.path.join(self.unit_test_dir, '50 noncross options') |
| self.init(testdir, extra_args=['-Dpkg_config_path=' + testdir]) |
| compdb = self.get_compdb() |
| self.assertEqual(len(compdb), 2) |
| self.assertRegex(compdb[0]['command'], '-std=c99') |
| self.assertRegex(compdb[1]['command'], '-std=c99') |
| self.build() |
| |
| def test_identity_cross(self): |
| testdir = os.path.join(self.unit_test_dir, '60 identity cross') |
| |
| constantsfile = tempfile.NamedTemporaryFile(mode='w', encoding='utf-8') |
| constantsfile.write(textwrap.dedent('''\ |
| [constants] |
| py_ext = '.py' |
| ''')) |
| constantsfile.flush() |
| |
| nativefile = tempfile.NamedTemporaryFile(mode='w', encoding='utf-8') |
| nativefile.write(textwrap.dedent('''\ |
| [binaries] |
| c = ['{}' + py_ext] |
| '''.format(os.path.join(testdir, 'build_wrapper')))) |
| nativefile.flush() |
| self.meson_native_files = [constantsfile.name, nativefile.name] |
| |
| crossfile = tempfile.NamedTemporaryFile(mode='w', encoding='utf-8') |
| crossfile.write(textwrap.dedent('''\ |
| [binaries] |
| c = ['{}' + py_ext] |
| '''.format(os.path.join(testdir, 'host_wrapper')))) |
| crossfile.flush() |
| self.meson_cross_files = [constantsfile.name, crossfile.name] |
| |
| # TODO should someday be explicit about build platform only here |
| self.init(testdir) |
| |
| def test_identity_cross_env(self): |
| testdir = os.path.join(self.unit_test_dir, '60 identity cross') |
| env = { |
| 'CC_FOR_BUILD': '"' + os.path.join(testdir, 'build_wrapper.py') + '"', |
| 'CC': '"' + os.path.join(testdir, 'host_wrapper.py') + '"', |
| } |
| crossfile = tempfile.NamedTemporaryFile(mode='w', encoding='utf-8') |
| crossfile.write('') |
| crossfile.flush() |
| self.meson_cross_files = [crossfile.name] |
| # TODO should someday be explicit about build platform only here |
| self.init(testdir, override_envvars=env) |
| |
| @skipIfNoPkgconfig |
| def test_static_link(self): |
| if is_cygwin(): |
| raise SkipTest("Cygwin doesn't support LD_LIBRARY_PATH.") |
| |
| # Build some libraries and install them |
| testdir = os.path.join(self.unit_test_dir, '66 static link/lib') |
| libdir = os.path.join(self.installdir, self.libdir) |
| oldprefix = self.prefix |
| self.prefix = self.installdir |
| self.init(testdir) |
| self.install(use_destdir=False) |
| |
| # Test that installed libraries works |
| self.new_builddir() |
| self.prefix = oldprefix |
| meson_args = [f'-Dc_link_args=-L{libdir}', |
| '--fatal-meson-warnings'] |
| testdir = os.path.join(self.unit_test_dir, '66 static link') |
| env = {'PKG_CONFIG_LIBDIR': os.path.join(libdir, 'pkgconfig')} |
| self.init(testdir, extra_args=meson_args, override_envvars=env) |
| self.build() |
| self.run_tests() |
| |
| def _check_ld(self, check: str, name: str, lang: str, expected: str) -> None: |
| if is_sunos(): |
| raise SkipTest('Solaris currently cannot override the linker.') |
| if not shutil.which(check): |
| raise SkipTest(f'Could not find {check}.') |
| envvars = [mesonbuild.envconfig.ENV_VAR_PROG_MAP[f'{lang}_ld']] |
| |
| # Also test a deprecated variable if there is one. |
| if f'{lang}_ld' in mesonbuild.envconfig.DEPRECATED_ENV_PROG_MAP: |
| envvars.append( |
| mesonbuild.envconfig.DEPRECATED_ENV_PROG_MAP[f'{lang}_ld']) |
| |
| for envvar in envvars: |
| with mock.patch.dict(os.environ, {envvar: name}): |
| env = get_fake_env() |
| comp = compiler_from_language(env, lang, MachineChoice.HOST) |
| if isinstance(comp, (AppleClangCCompiler, AppleClangCPPCompiler, |
| AppleClangObjCCompiler, AppleClangObjCPPCompiler)): |
| raise SkipTest('AppleClang is currently only supported with ld64') |
| if lang != 'rust' and comp.use_linker_args('bfd', '') == []: |
| raise SkipTest( |
| f'Compiler {comp.id} does not support using alternative linkers') |
| self.assertEqual(comp.linker.id, expected) |
| |
| def test_ld_environment_variable_bfd(self): |
| self._check_ld('ld.bfd', 'bfd', 'c', 'ld.bfd') |
| |
| def test_ld_environment_variable_gold(self): |
| self._check_ld('ld.gold', 'gold', 'c', 'ld.gold') |
| |
| def test_ld_environment_variable_lld(self): |
| self._check_ld('ld.lld', 'lld', 'c', 'ld.lld') |
| |
| @skip_if_not_language('rust') |
| @skipIfNoExecutable('ld.gold') # need an additional check here because _check_ld checks for gcc |
| def test_ld_environment_variable_rust(self): |
| self._check_ld('gcc', 'gcc -fuse-ld=gold', 'rust', 'ld.gold') |
| |
| def test_ld_environment_variable_cpp(self): |
| self._check_ld('ld.gold', 'gold', 'cpp', 'ld.gold') |
| |
| @skip_if_not_language('objc') |
| def test_ld_environment_variable_objc(self): |
| self._check_ld('ld.gold', 'gold', 'objc', 'ld.gold') |
| |
| @skip_if_not_language('objcpp') |
| def test_ld_environment_variable_objcpp(self): |
| self._check_ld('ld.gold', 'gold', 'objcpp', 'ld.gold') |
| |
| @skip_if_not_language('fortran') |
| def test_ld_environment_variable_fortran(self): |
| self._check_ld('ld.gold', 'gold', 'fortran', 'ld.gold') |
| |
| @skip_if_not_language('d') |
| def test_ld_environment_variable_d(self): |
| # At least for me, ldc defaults to gold, and gdc defaults to bfd, so |
| # let's pick lld, which isn't the default for either (currently) |
| if is_osx(): |
| expected = 'ld64' |
| else: |
| expected = 'ld.lld' |
| self._check_ld('ld.lld', 'lld', 'd', expected) |
| |
| def compute_sha256(self, filename): |
| with open(filename, 'rb') as f: |
| return hashlib.sha256(f.read()).hexdigest() |
| |
| def test_wrap_with_file_url(self): |
| testdir = os.path.join(self.unit_test_dir, '72 wrap file url') |
| source_filename = os.path.join(testdir, 'subprojects', 'foo.tar.xz') |
| patch_filename = os.path.join(testdir, 'subprojects', 'foo-patch.tar.xz') |
| wrap_filename = os.path.join(testdir, 'subprojects', 'foo.wrap') |
| source_hash = self.compute_sha256(source_filename) |
| patch_hash = self.compute_sha256(patch_filename) |
| wrap = textwrap.dedent("""\ |
| [wrap-file] |
| directory = foo |
| |
| source_url = http://server.invalid/foo |
| source_fallback_url = file://{} |
| source_filename = foo.tar.xz |
| source_hash = {} |
| |
| patch_url = http://server.invalid/foo |
| patch_fallback_url = file://{} |
| patch_filename = foo-patch.tar.xz |
| patch_hash = {} |
| """.format(source_filename, source_hash, patch_filename, patch_hash)) |
| with open(wrap_filename, 'w', encoding='utf-8') as f: |
| f.write(wrap) |
| self.init(testdir) |
| self.build() |
| self.run_tests() |
| |
| windows_proof_rmtree(os.path.join(testdir, 'subprojects', 'packagecache')) |
| windows_proof_rmtree(os.path.join(testdir, 'subprojects', 'foo')) |
| os.unlink(wrap_filename) |
| |
| def test_no_rpath_for_static(self): |
| testdir = os.path.join(self.common_test_dir, '5 linkstatic') |
| self.init(testdir) |
| self.build() |
| build_rpath = get_rpath(os.path.join(self.builddir, 'prog')) |
| self.assertIsNone(build_rpath) |
| |
| def test_lookup_system_after_broken_fallback(self): |
| # Just to generate libfoo.pc so we can test system dependency lookup. |
| testdir = os.path.join(self.common_test_dir, '44 pkgconfig-gen') |
| self.init(testdir) |
| privatedir = self.privatedir |
| |
| # Write test project where the first dependency() returns not-found |
| # because 'broken' subproject does not exit, but that should not prevent |
| # the 2nd dependency() to lookup on system. |
| self.new_builddir() |
| with tempfile.TemporaryDirectory() as d: |
| with open(os.path.join(d, 'meson.build'), 'w', encoding='utf-8') as f: |
| f.write(textwrap.dedent('''\ |
| project('test') |
| dependency('notfound', fallback: 'broken', required: false) |
| dependency('libfoo', fallback: 'broken', required: true) |
| ''')) |
| self.init(d, override_envvars={'PKG_CONFIG_LIBDIR': privatedir}) |
| |
| def test_as_link_whole(self): |
| testdir = os.path.join(self.unit_test_dir, '76 as link whole') |
| self.init(testdir) |
| with open(os.path.join(self.privatedir, 'bar1.pc'), encoding='utf-8') as f: |
| content = f.read() |
| self.assertIn('-lfoo', content) |
| with open(os.path.join(self.privatedir, 'bar2.pc'), encoding='utf-8') as f: |
| content = f.read() |
| self.assertNotIn('-lfoo', content) |
| |
| def test_prelinking(self): |
| # Prelinking currently only works on recently new GNU toolchains. |
| # Skip everything else. When support for other toolchains is added, |
| # remove limitations as necessary. |
| if is_osx(): |
| raise SkipTest('Prelinking not supported on Darwin.') |
| if 'clang' in os.environ.get('CC', 'dummy'): |
| raise SkipTest('Prelinking not supported with Clang.') |
| testdir = os.path.join(self.unit_test_dir, '86 prelinking') |
| env = get_fake_env(testdir, self.builddir, self.prefix) |
| cc = detect_c_compiler(env, MachineChoice.HOST) |
| if cc.id == "gcc" and not version_compare(cc.version, '>=9'): |
| raise SkipTest('Prelinking not supported with gcc 8 or older.') |
| self.init(testdir) |
| self.build() |
| outlib = os.path.join(self.builddir, 'libprelinked.a') |
| ar = shutil.which('ar') |
| self.assertPathExists(outlib) |
| self.assertIsNotNone(ar) |
| p = subprocess.run([ar, 't', outlib], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.DEVNULL, |
| text=True, timeout=1) |
| obj_files = p.stdout.strip().split('\n') |
| self.assertEqual(len(obj_files), 1) |
| self.assertTrue(obj_files[0].endswith('-prelink.o')) |
| |
| def do_one_test_with_nativefile(self, testdir, args): |
| testdir = os.path.join(self.common_test_dir, testdir) |
| with tempfile.TemporaryDirectory() as d: |
| p = Path(d) / 'nativefile' |
| with p.open('wt', encoding='utf-8') as f: |
| f.write(f'''[binaries] |
| c = {args} |
| ''') |
| self.init(testdir, extra_args=['--native-file=' + str(p)]) |
| self.build() |
| |
| def test_cmake_multilib(self): |
| ''' |
| Test that the cmake module handles multilib paths correctly. |
| ''' |
| # Verify that "gcc -m32" works |
| try: |
| self.do_one_test_with_nativefile('1 trivial', "['gcc', '-m32']") |
| except subprocess.CalledProcessError as e: |
| raise SkipTest('Not GCC, or GCC does not have the -m32 option') |
| self.wipe() |
| |
| # Verify that cmake works |
| try: |
| self.do_one_test_with_nativefile('../cmake/1 basic', "['gcc']") |
| except subprocess.CalledProcessError as e: |
| raise SkipTest('Could not build basic cmake project') |
| self.wipe() |
| |
| # If so, we can test that cmake works with "gcc -m32" |
| self.do_one_test_with_nativefile('../cmake/1 basic', "['gcc', '-m32']") |
| |
| @skipUnless(is_linux() or is_osx(), 'Test only applicable to Linux and macOS') |
| def test_install_strip(self): |
| testdir = os.path.join(self.unit_test_dir, '104 strip') |
| self.init(testdir) |
| self.build() |
| |
| destdir = self.installdir + self.prefix |
| if is_linux(): |
| lib = os.path.join(destdir, self.libdir, 'liba.so') |
| else: |
| lib = os.path.join(destdir, self.libdir, 'liba.dylib') |
| install_cmd = self.meson_command + ['install', '--destdir', self.installdir] |
| |
| # Check we have debug symbols by default |
| self._run(install_cmd, workdir=self.builddir) |
| if is_linux(): |
| # file can detect stripped libraries on linux |
| stdout = self._run(['file', '-b', lib]) |
| self.assertIn('not stripped', stdout) |
| else: |
| # on macOS we need to query dsymutil instead. |
| # Alternatively, check if __dyld_private is defined |
| # in the output of nm liba.dylib, but that is not |
| # 100% reliable, it needs linking to an external library |
| stdout = self._run(['dsymutil', '--dump-debug-map', lib]) |
| self.assertIn('symbols:', stdout) |
| |
| # Check debug symbols got removed with --strip |
| self._run(install_cmd + ['--strip'], workdir=self.builddir) |
| if is_linux(): |
| stdout = self._run(['file', '-b', lib]) |
| self.assertNotIn('not stripped', stdout) |
| else: |
| stdout = self._run(['dsymutil', '--dump-debug-map', lib]) |
| self.assertNotIn('symbols:', stdout) |
| |
| def test_isystem_default_removal_with_symlink(self): |
| env = get_fake_env() |
| cpp = detect_cpp_compiler(env, MachineChoice.HOST) |
| default_dirs = cpp.get_default_include_dirs() |
| default_symlinks = [] |
| with tempfile.TemporaryDirectory() as tmpdir: |
| for i in range(len(default_dirs)): |
| symlink = f'{tmpdir}/default_dir{i}' |
| default_symlinks.append(symlink) |
| os.symlink(default_dirs[i], symlink) |
| self.assertFalse(cpp.compiler_args([f'-isystem{symlink}' for symlink in default_symlinks]).to_native()) |
| |
| def test_freezing(self): |
| testdir = os.path.join(self.unit_test_dir, '110 freeze') |
| self.init(testdir) |
| self.build() |
| with self.assertRaises(subprocess.CalledProcessError) as e: |
| self.run_tests() |
| self.assertNotIn('Traceback', e.exception.output) |
| |
| @skipUnless(is_linux(), "Ninja file differs on different platforms") |
| def test_complex_link_cases(self): |
| testdir = os.path.join(self.unit_test_dir, '114 complex link cases') |
| self.init(testdir) |
| self.build() |
| with open(os.path.join(self.builddir, 'build.ninja'), encoding='utf-8') as f: |
| content = f.read() |
| # Verify link dependencies, see comments in meson.build. |
| self.assertIn('build libt1-s3.a: STATIC_LINKER libt1-s2.a.p/s2.c.o libt1-s3.a.p/s3.c.o\n', content) |
| self.assertIn('build t1-e1: c_LINKER t1-e1.p/main.c.o | libt1-s1.a libt1-s3.a\n', content) |
| self.assertIn('build libt2-s3.a: STATIC_LINKER libt2-s2.a.p/s2.c.o libt2-s1.a.p/s1.c.o libt2-s3.a.p/s3.c.o\n', content) |
| self.assertIn('build t2-e1: c_LINKER t2-e1.p/main.c.o | libt2-s3.a\n', content) |
| self.assertIn('build t3-e1: c_LINKER t3-e1.p/main.c.o | libt3-s3.so.p/libt3-s3.so.symbols\n', content) |
| self.assertIn('build t4-e1: c_LINKER t4-e1.p/main.c.o | libt4-s2.so.p/libt4-s2.so.symbols libt4-s3.a\n', content) |
| self.assertIn('build t5-e1: c_LINKER t5-e1.p/main.c.o | libt5-s1.so.p/libt5-s1.so.symbols libt5-s3.a\n', content) |
| self.assertIn('build t6-e1: c_LINKER t6-e1.p/main.c.o | libt6-s2.a libt6-s3.a\n', content) |
| self.assertIn('build t7-e1: c_LINKER t7-e1.p/main.c.o | libt7-s3.a\n', content) |
| self.assertIn('build t8-e1: c_LINKER t8-e1.p/main.c.o | libt8-s1.a libt8-s2.a libt8-s3.a\n', content) |
| self.assertIn('build t9-e1: c_LINKER t9-e1.p/main.c.o | libt9-s1.a libt9-s2.a libt9-s3.a\n', content) |
| self.assertIn('build t12-e1: c_LINKER t12-e1.p/main.c.o | libt12-s1.a libt12-s2.a libt12-s3.a\n', content) |
| self.assertIn('build t13-e1: c_LINKER t13-e1.p/main.c.o | libt12-s1.a libt13-s3.a\n', content) |
