summaryrefslogtreecommitdiffstats
path: root/unittests/linuxliketests.py
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-29 04:41:38 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-29 04:41:38 +0000
commit7b6e527f440cd7e6f8be2b07cee320ee6ca18786 (patch)
tree4a2738d69fa2814659fdadddf5826282e73d81f4 /unittests/linuxliketests.py
parentInitial commit. (diff)
downloadmeson-7b6e527f440cd7e6f8be2b07cee320ee6ca18786.tar.xz
meson-7b6e527f440cd7e6f8be2b07cee320ee6ca18786.zip
Adding upstream version 1.0.1.upstream/1.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'unittests/linuxliketests.py')
-rw-r--r--unittests/linuxliketests.py1830
1 files changed, 1830 insertions, 0 deletions
diff --git a/unittests/linuxliketests.py b/unittests/linuxliketests.py
new file mode 100644
index 0000000..50c6b62
--- /dev/null
+++ b/unittests/linuxliketests.py
@@ -0,0 +1,1830 @@
+# 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 import PkgConfigDependency
+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_pkgconfig_variable('foo', [], None), 'bar')
+ self.assertPathEqual(foo_dep.get_pkgconfig_variable('datadir', [], None), '/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_pkgconfig_variable('foo', [], None), 'bar')
+ self.assertEqual(libhello_nolib.get_pkgconfig_variable('prefix', [], None), self.prefix)
+ if version_compare(PkgConfigDependency.check_pkgconfig(env, libhello_nolib.pkgbin),">=0.29.1"):
+ self.assertEqual(libhello_nolib.get_pkgconfig_variable('escaped_var', [], None), r'hello\ world')
+ self.assertEqual(libhello_nolib.get_pkgconfig_variable('unescaped_var', [], None), '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_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
+ # 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')
+ 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.
+ PkgConfigDependency.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, '97 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, '97 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')
+ constantsfile.write(textwrap.dedent('''\
+ [constants]
+ py_ext = '.py'
+ '''))
+ constantsfile.flush()
+
+ nativefile = tempfile.NamedTemporaryFile(mode='w')
+ 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')
+ 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')
+ 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, '103 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, '109 freeze')
+ self.init(testdir)
+ self.build()
+ with self.assertRaises(subprocess.CalledProcessError) as e:
+ self.run_tests()
+ self.assertNotIn('Traceback', e.exception.output)