text: # Copyright 2016-2021 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
  
  
  from run_tests import (
      get_fake_env
  )
  
  from .baseplatformtests import BasePlatformTests
  from .helpers import *
  
  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', {}), 'bar')
          self.assertPathEqual(foo_dep.get_pkgconfig_variable('datadir', {}), '/usr/data')
  
          libhello_nolib = PkgConfigDependency('libhello_nolib', env, kwargs)
          self.assertTrue(libhello_nolib.found())
          self.assertEqual(libhello_nolib.get_link_args(), [])
          self.assertEqual(libhello_nolib.get_compile_args(), [])
          self.assertEqual(libhello_nolib.get_pkgconfig_variable('foo', {}), 'bar')
          self.assertEqual(libhello_nolib.get_pkgconfig_variable('prefix', {}), self.prefix)
          if version_compare(libhello_nolib.check_pkgconfig(libhello_nolib.pkgbin),">=0.29.1"):
              self.assertEqual(libhello_nolib.get_pkgconfig_variable('escaped_var', {}), r'hello\ world')
          self.assertEqual(libhello_nolib.get_pkgconfig_variable('unescaped_var', {}), 'hello world')
  
          cc = detect_c_compiler(env, MachineChoice.HOST)
          if cc.get_id() in {'gcc', 'clang'}:
              for name in {'ct', 'ct0'}:
                  ct_dep = PkgConfigDependency(name, env, kwargs)
                  self.assertTrue(ct_dep.found())
                  self.assertIn('-lct', ct_dep.get_link_args())
  
      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.assertFalse('blub_blob_blib' in 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 Qt5
          if not shutil.which('qmake-qt6'):
              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)
  
      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.
          '''
          # 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.
          '''
          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.
          '''
          # 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, '90 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, '80 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_file = 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.assertFalse(b'libpkgdep-int' in 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.assertFalse(b'glib' in 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, '62 pkgconfig relative paths')
          pkg_dir = os.path.join(testdir, 'pkgconfig')
          self.assertTrue(os.path.exists(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='')
  
          PkgConfigDependency.setup_env({}, env, MachineChoice.HOST, pkg_dir)
          pkg_config_path = env.coredata.options[OptionKey('pkg_config_path')].value
          self.assertTrue(len(pkg_config_path) == 1)
  
      @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, '66 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'] = 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, '50 pkgconfig csharp library')
          self.init(testdir)
          myenv = os.environ.copy()
          myenv['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, '53 pkgconfig static link order')
          self.init(testdir)
          myenv = os.environ.copy()
          myenv['PKG_CONFIG_PATH'] = self.privatedir
          stdo = subprocess.check_output(['pkg-config', '--libs', 'libsomething'], env=myenv)
          deps = stdo.split()
          self.assertTrue(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, '43 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, '42 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, '40 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': os.path.join(installdir, self.libdir, 'pkgconfig')}
          testdir = os.path.join(self.unit_test_dir, '40 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': 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, '75 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, '75 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, '75 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, '52 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, '56 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, '51 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, '61 identity cross')
  
          nativefile = tempfile.NamedTemporaryFile(mode='w')
          nativefile.write(textwrap.dedent('''\
              [binaries]
              c = ['{}']
              '''.format(os.path.join(testdir, 'build_wrapper.py'))))
          nativefile.flush()
          self.meson_native_file = nativefile.name
  
          crossfile = tempfile.NamedTemporaryFile(mode='w')
          crossfile.write(textwrap.dedent('''\
              [binaries]
              c = ['{}']
              '''.format(os.path.join(testdir, 'host_wrapper.py'))))
          crossfile.flush()
          self.meson_cross_file = 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, '61 identity cross')
          env = {
              'CC_FOR_BUILD': '"' + os.path.join(testdir, 'build_wrapper.py') + '"',
          }
          crossfile = tempfile.NamedTemporaryFile(mode='w')
          crossfile.write(textwrap.dedent('''\
              [binaries]
              c = ['{}']
              '''.format(os.path.join(testdir, 'host_wrapper.py'))))
          crossfile.flush()
          self.meson_cross_file = 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, '67 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, '67 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, '73 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, '77 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, '87 prelinking')
          env = get_fake_env(testdir, self.builddir, self.prefix)
          cc = detect_c_compiler(env, MachineChoice.HOST)
          if cc.id == "gcc":
              gccver = subprocess.check_output(['gcc', '--version'])
              if b'7.5.0' in gccver:
                  raise SkipTest('GCC on Bionic is too old to be supported.')
          self.init(testdir)
          self.build()
          outlib = os.path.join(self.builddir, 'libprelinked.a')
          ar = shutil.which('ar')
          self.assertTrue(os.path.exists(outlib))
          self.assertTrue(ar is not None)
          p = subprocess.run([ar, 't', outlib],
                             stdout=subprocess.PIPE,
                             stderr=subprocess.DEVNULL,
                             universal_newlines=True, timeout=1)
          obj_files = p.stdout.strip().split('\n')
          self.assertEqual(len(obj_files), 1)
          self.assertTrue(obj_files[0].endswith('-prelink.o'))
  