|
|
|
# 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,
|
|
|
|
AppleClangCCompiler, AppleClangCPPCompiler, AppleClangObjCCompiler,
|
|
|
|
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(libhello_nolib.check_pkgconfig(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())
|
|
|
|
|
|
|
|
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()
|
|
|
|
if qt4 == 0:
|
|
|
|
self.assertRegex('\n'.join(mesonlog),
|
|
|
|
r'Run-time dependency qt4 \(modules: Core\) found: YES 4.* \(pkg-config\)')
|
|
|
|
if qt5 == 0:
|
|
|
|
self.assertRegex('\n'.join(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()
|
|
|
|
self.assertRegex('\n'.join(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()
|
|
|
|
self.assertRegex('\n'.join(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------T'
|
|
|
|
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--t'
|
|
|
|
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-T'),
|
|
|
|
('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-T'),
|
|
|
|
('share/sub1', 'drwxr-x---'),
|
|
|
|
('share/sub1/second.dat', '-rwxr-x--t'),
|
|
|
|
('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')
|
|
|
|
mesonbuild.modules.gnome.native_glib_version = '2.20'
|
|
|
|
env = {'MESON_UNIT_TEST_PRETEND_GLIB_OLD': "1"}
|
|
|
|
try:
|
|
|
|
self.init(testdir,
|
|
|
|
inprocess=True,
|
|
|
|
override_envvars=env)
|
|
|
|
self.build(override_envvars=env)
|
|
|
|
finally:
|
|
|
|
mesonbuild.modules.gnome.native_glib_version = None
|
|
|
|
|
|
|
|
@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, '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')
|
|
|
|
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'))
|
cmake: handle arguments in the [binaries] section of the machine file
Sometimes, the machine file can include compiler command line options,
in order to pick the correct multilib. For example, Meson uses "$cc
--print-search-dirs" to find the library search path, where $cc is the
cc from the machine file. Because the outputs of "gcc -m32
--print-search-dirs" and "gcc --print-search-dirs" are different, this
only works if you have
[binaries]
cc = ['gcc', '-m32']
in the machine file. Right now, however, the cmake module assumes that
the compiler listed in the machine file is either a compiler, or a
"launcher" followed by the compiler. Check if the second argument
starts with a slash (for Microsoft-like compilers) or a dash (for
everyone else), and if so presume that the CMAKE_*_COMPILER_LAUNCHER
need not be defined.
3 years ago
|
|
|
|
|
|
|
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(), 'Test only applicable to Linux')
|
|
|
|
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
|
|
|
|
lib = os.path.join(destdir, self.libdir, 'liba.so')
|
|
|
|
install_cmd = self.meson_command + ['install', '--destdir', self.installdir]
|
|
|
|
|
|
|
|
# Check we have debug symbols by default
|
|
|
|
self._run(install_cmd, workdir=self.builddir)
|
|
|
|
stdout = self._run(['file', '-b', lib])
|
|
|
|
self.assertIn('not stripped', stdout)
|
|
|
|
|
|
|
|
# Check debug symbols got removed with --strip
|
|
|
|
self._run(install_cmd + ['--strip'], workdir=self.builddir)
|
|
|
|
stdout = self._run(['file', '-b', lib])
|
|
|
|
self.assertNotIn('not stripped', stdout)
|